小编Hen*_*gon的帖子

鉴于STM拥有refs,agent等10个值的历史记录,可以读取这些值吗？

原因是,我正在更新一堆代理商,我需要保留价值历史.如果STM已经保留它们,我宁愿只使用它们.我在API中找不到看起来像是从STM历史中读取值的函数,所以我猜不是,也不能在java源代码中找到任何方法,但也许我看起来不对.

将函数映射到序列中每个第n个元素的简洁方法是什么？类似的东西(map-every-nth fn coll n),它将返回原始序列,只有每个第n个元素被转换,例如(map-every-nth inc(范围16)4)将返回(0 1 2 4 4 5 6 8 8 9 10 12 12 13 14 16)

什么是固定长度堆栈的最佳数据结构(我最初称之为队列,但我想要的是一个堆栈),其中项目被添加到前面,每次将项目添加到前面时,项目将从结束？从前面也可以访问各种长度的子向量.我正在使用矢量,现在考虑clojure.lang.PersistentQueue和手指树.

编辑,澄清,例如:

> (def q (queue [1 2 3 4]))
[1 2 3 4]
> (push q 9 8 7)
[7 8 9 1]
> (peek (push q 9 8 7))
7

edit2:感谢你到目前为止所有的答案,这已经变成了回归基础和阅读Clojure的乐趣的练习,例如学习subvec的subvec保留对第一个subvec的向量的引用,而像(vec(cons) x(subvec ...如果反复使用会产生对所有中间子集的引用.鉴于此,如何推送基于矢量的队列的推送？:

(defn push [v i n] (if (>= (count v) n) (conj (subvec v 1 n) i) (conj v i) ) )

然后可以通过rseq访问生成的向量,我相信它对向量很快(由于它使用索引偏移？)

阅读了一些关于这个主题的博客文章,我发现在Clojure中改变一个数组是这样的:

(defn m [xs ys] 
  (dotimes [i (count xs)] 
    (aset #^ints ys (int i) 
    (int (* (int 3) (int (aget #^ints xs (int i))))))))

在哪里(def xs (into-array Integer/TYPE (range 1000000)))和(def ys (into-array Integer/TYPE (range 1000000)))

根据Criterium,平均花费了14ms,而Java也是如此,

public static int[] m(int[] x, int[] y)
{
  for(int i=0; i<x.length; i++)
    y[i] = 3*x[i];
  return y;
}

平均需要800us.**

我是否竭尽所能让事情变得更快,还有什么可以进入优化路径吗？

**我使用(report-result (bench (m xs ys )) :verbose)和时间使用Criterium计时(report-result (bench (. Test m xs ys)) :verbose)

是否有一个Clojurescript库使DOM看起来像Clojure数据结构？我发现像Enfocus这样的一些库可以进行某些类型的DOM操作,但我想要的是能够像这样处理DOM:

(get dom id) - returns element called id in dom
(get dom id create-fn) - return element if exists, otherwise creates it
(update-in dom [:body this that] update-fn) - set attribute on a DOM element 
(assoc parent-element id child-element) - associate child element with parent
(conj parent child) - append child element to parent element

等等

我正在尝试解析PriorityMaps的嵌套结构:

(def reader-map
 {
   'util/pm (fn [x] (println "reading > " x) (parse-map x))
})

(binding [*data-readers* reader-map]
    (clojure.core/read-string "#util/pm \"{:z 4 :y #util/pm \"{:y 3 :x 3}\" :x 9}\""))

...但是我没有看到嵌套的字符串像我期望的那样传递到我的处理程序中,只看到第一个嵌套标记的字符串:

 reading >  {:z 4 :y #er.util.net/pm

我做错了什么？

我发现我很少let在Clojure中使用.出于某种原因,当我开始学习并从那时起就避免使用它时,我不喜欢它.当流动时,感觉流动停止了let.我想知道,你认为我们可以完全没有它吗？

如果我为另一个命名空间（我无法更改的库）声明一个多方法，ns-a，对于我的类型：

defmethod ns-a/method-a Y [y]

ns-a 中定义了 X 的现有方法：

defmethod method-a X [x]

调度函数是

(defmulti method-a type)

如果我的类型 Y 也是 X，我如何在 Y 的实现中分派到 X 的实现？

编辑：我发现了一个黑客：

(defmethod ns-a/method-a Y [y]
 (do-special-Y-stuff-here y)
    ; now do X stuff with Y:
    ((get-method ns-a/method-a X) y)
)

如果我有一个符号,其命名空间是别名,如q/w,我怎样才能找到它的实际命名空间,比如actual.namespace/w？

我知道这resolve将给我完全限定的var,但我不知道如何获得var的命名空间.

我能做的最好的事情是:

 (defn fqns [s] (str (get (ns-aliases *ns*) (symbol (namespace s)))))

当然有一种更简单的方法吗？

我在地图中有原子,这可能是也可能不是一个好主意,但关键是我需要对原子进行deref,这样我就可以对地图进行json-str,并且json-str不能处​​理原子,所以我写了这个:

(defn deatomize- [m]
 (cond
   (instance? clojure.lang.Atom m) #(deatomize- @m)
   (map? m) (zipmap (keys m) (map #(trampoline deatomize- %) (vals m)))
   :else m
 )
)

(defn deatomize [m] (trampoline deatomize- m))

这似乎有效,但a)它是好的,b)有更好的方法吗？

我遇到了一个我今天需要的东西,我希望逐步将地图中的条目关联起来,每个条目都基于前一个的结果.这是我做的:

(defn -Y [v k f] (assoc v k (f v)))

(defn build-map [a-map]
 (-> a-map
  (-Y :x #(reduce + (:values %) )  )
  (-Y :y #(/ (:x %) 100) )
  (-Y :z #(* (:y %) 10000000) )
 )
)
(build-map {:values (range 8)})

我欢迎你的想法a)这是一件好事吗？b)有没有现成的方法可以做到我没见过？(我不太了解API)

我正在使用 Datascript 查询具有给定名称的 2 个节点的最后一个共同祖先的树结构，这是我到目前为止所得到的，但它真的很慢 - 知道为什么（或者有更好的方法）？

(defn lca
  "Last common ancestor"
  [db name1 name2]
  (d/q '[
          :find [(pull ?anc [:db/id :name]) ...]
          :in    $ % ?name1 ?name2
          :where
            (?node1 :name ?name1)
            (?node2 :name ?name2)
            (anc ?anc1 ?node1)
            (anc ?anc2 ?node2)
            [(not= ?anc1 ?anc2)]
            (parent ?anc ?anc1)
            (parent ?anc ?anc2)
          ]
          @db
          '[
            [ (parent ?par ?child)
              (?par :children ?child)]
            [ (anc ?par ?child)
              (?par :children ?child)]
            [ (anc ?anc ?child)
              (?par :children ?child)
              (anc ?anc ?par)]
            ] …