clojure - walk vs map 处理序列

Question

据我了解，walk 和 map 都将函数应用于 seq。（walk 还允许应用outer函数后处理）。但是，使用一个而不是另一个的惯用案例是什么？

Answer 1

的语义map基本上是：将函数应用于集合中的每个项目并按顺序懒惰地返回结果：

(map inc #{0 1 2}) ;outputs (when realized) (1 2 3)

请注意，输入是一个集合，但输出是一个序列。

walk 的语义基本上是：创建一个相同类型的集合，其中每个项目已被inner该项目的函数值替换，返回应用outer到新集合的结果：

(walk inc identity #{0 1 2}) ;outputs #{1 2 3}

如果您查看 walk API ( http://richhickey.github.com/clojure/clojure.walk-api.html ) 中其他函数的源代码，您可以看到如何使 walk 递归（或只需使用那些其他功能）。

至于成语，我不确定。但是更复杂，因此在不需要提供的语义的情况下，walk您可能应该坚持使用。mapwalk

Answer 2

将函数应用于 seq 是 map 的工作。当您必须遍历并递归地遍历整个结构时，请使用 walk。

s 的一些示例walk可以在ClojureDocs中找到，也可以在 REPL 中找到，例如(user/clojuredocs clojure.walk/postwalk)。许多示例都是教学性的，可以而且应该在实践中使用mapor for（有时reduce）来完成。

a 的典型用例walk是当您有一个希望递归处理的嵌套结构时。这可能有用的一些示例是clojure.walk名称空间本身，例如查看(source clojure.walk/keywordize-keys). [注意，如果您想迭代或随意处理它，请使用 zippers（或tree-seq对于一些更简单的迭代情况）。]

想到的另一个例子是解释解析树：

(require '[clojure.walk :as w])

(def t [+ [* [- 6 2] [/ 9 3]] [* 2 [+ 7 8]]])

(w/postwalk #(if (and (coll? %) (fn? (first %))) (apply (first %) (next %)) %) t)
;=> 42

或许有用，例如，替换fn?为allowed-fn?等来评估edn表达式，而不是调用功能太强大的 eval 编译器：

(eval t) ;=> [#<core$_PLUS_ ... ] 

糟糕，表单是列表，而不是向量：

(def s (w/postwalk #(if (coll? %) (apply list %) %) t))
s ;=> (#<core$_PLUS_ ... )
(eval s) ;=> 42

啊，请注意这里的另一种用法walk- 递归地将结构从嵌套向量更改为嵌套列表。

一个反复思考的例子：

(require '[clojure.walk :as w])

(def s1 (range 8))
s1 ;=> (0 1 2 3 4 5 6 7)
(map inc s1)
;=> (1 2 3 4 5 6 7 8)
(w/postwalk #(if (number? %) (inc %) %) s1)
;=> (1 2 3 4 5 6 7 8)

(def s2 (partition 2 s1))
s2 ;=> ((0 1) (2 3) (4 5) (6 7))
(map (partial map inc) s2)
;=> ((1 2) (3 4) (5 6) (7 8))
(w/postwalk #(if (number? %) (inc %) %) s2)
;=> ((1 2) (3 4) (5 6) (7 8))

(def s3 (partition 2 s2))
s3 ;=> ((0 1) (2 3) (4 5) (6 7))
(map (partial map (partial map inc)) s3)
;=> (((1 2) (3 4)) ((5 6) (7 8)))
(w/postwalk #(if (number? %) (inc %) %) s3)
;=> (((1 2) (3 4)) ((5 6) (7 8)))

(def s4 (partition 2 s3))
s4 ;=> ((((0 1) (2 3)) ((4 5) (6 7))))
(map (partial map (partial map (partial map inc))) s4)
;=> ((((1 2) (3 4)) ((5 6) (7 8))))
(w/postwalk #(if (number? %) (inc %) %) s4)
;=> ((((1 2) (3 4)) ((5 6) (7 8))))

Answer 3

对于map，我认为惯用的用例非常明确：当您需要按顺序转换所有内容时，请使用它。

对于clojure.walk/walk，我认为惯用的用例是：当您需要按顺序转换所有内容然后执行apply fn操作时。

(clojure.walk/walk second #(apply +  %)  [["a" 1] ["b" 2] ["c" 3]])
;; => 6

(clojure.walk/walk first #(apply concat %)  [["ab" 1] ["b" 2] ["c" 3]])
;; => (\a \b \b \c)

(mapcat first [["ab" 1] ["b" 2] ["c" 3]])
;; => (\a \b \b \c)

clojure.walk/walk注意和之间的相似性mapcat，我个人认为 walk 是 mapcat 的一般形式。