Walk vs map для обработки seq

Ответ 1

Применением функции к seq является задание карты. Используйте прогулку, когда вам нужно пройти через и рекурсивно во всю структуру.

Некоторые примеры walk можно найти на ClojureDocs, также доступном в REPL, например. (user/clojuredocs clojure.walk/postwalk). Многие из примеров являются педагогическими и могут и должны выполняться с помощью map или for (а иногда и reduce) на практике.

Типичный прецедент для walk - это когда у вас есть вложенная структура, которую вы хотите обработать рекурсивно. Некоторые примеры, когда это может быть полезно, - это само пространство имен clojure.walk, например. посмотрите (source clojure.walk/keywordize-keys). [Обратите внимание, что если вы хотите обработать его итеративно или по желанию, используйте молнии (или 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

Ah, обратите внимание на другое использование 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))))

Ответ 2

Семантика для map заключается в основном: применить функцию к каждому элементу в коллекции и лениво вернуть результаты в последовательности:

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

Обратите внимание, что вход был набором, но выход представляет собой последовательность.

Семантика для ходьбы в основном: создайте коллекцию того же типа, где каждый элемент был заменен значением функции inner для этого элемента, возвращает результат применения outer к новой коллекции:

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

Если вы посмотрите на исходный код для других функций API ходьбы (http://richhickey.github.com/clojure/clojure.walk-api.html), вы можете увидеть, как сделать рекурсивную прогулку ( или просто использовать эти другие функции).

Что касается идиом, я не уверен. Но walk более сложный, поэтому вы, вероятно, должны придерживаться map в тех случаях, когда вам не нужна семантика, которую предлагает walk.

Ответ 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.