什么是Clojure的可折叠系列？

Question

I am beginner to Clojure, while trying to read about Reducers I found something called foldable collection .

They are mentioning that vectors and maps are foldable collection, but not the list.

I am trying to understand what is foldable collection, why vectors and maps are foldable ?

I have not found any definition or explanation for foldable collection.

Answer 1

The answer is there in the docs, if not quite as clear as it could be:

Additionally, some collections (persistent vectors and maps) are foldable. The fold operation on a reducer executes the reduction in parallel...

The idea is that, with modern hardware, a "reduction" operation like summing all elements of a vector can be done in parallel. For example, if summing all elements of a 400K length vector, we could break them up into 4 groups of 100K chunks, sum those in parallel, then combine the 4 subtotals into the final answer. This would be approximately 4x faster than using only a single thread (single cpu core).

Reducers live in the clojure.core.reducers namespace. Assume we define aliases like:

( ns demo.xyz
  (:require [clojure.core :as core]
            [clojure.core.reducers :as r] ))

Compared to clojure.core , we have:

core/reduce   <=>   r/fold     ; new  name for `reduce`
core/map      <=>   r/map      ; same name for `map`
core/filter   <=>   r/filter   ; same name for `filter`

So, the naming is not the best. reduce lives in the clojure.core namespace, but there is no reduce in the clojure.core.reducers namespace. Instead, there is a work-alike function named fold in clojure.core.reducers .

Note that fold is a historical name for combining lists of data as with our summation example. See the Wikipedia entry for more information.

Because folding accesses the data in non-linear order (which is very ineffecient for linked lists), folding is only worth doing on random-access data structures like vectors).

---

Update #1 :

Having said the above, remember the adage that "Premature optimization is the root of all evil." Here are some measurements for (vec (range 1e7)) , ie 10M entries, on an 8-core machine:

(time (reduce + data))

"Elapsed time: 284.52735 msecs"
"Elapsed time: 119.310289 msecs"
"Elapsed time: 98.740421 msecs"
"Elapsed time: 100.58998 msecs"
"Elapsed time: 98.642878 msecs"
"Elapsed time: 105.021808 msecs"
"Elapsed time: 99.886083 msecs"
"Elapsed time: 98.49152 msecs"
"Elapsed time: 99.879767 msecs"

(time (r/fold + data))

"Elapsed time: 61.67537 msecs"
"Elapsed time: 56.811961 msecs"
"Elapsed time: 55.613058 msecs"
"Elapsed time: 58.359599 msecs"
"Elapsed time: 55.299767 msecs"
"Elapsed time: 62.989939 msecs"
"Elapsed time: 56.518486 msecs"
"Elapsed time: 54.218251 msecs"
"Elapsed time: 54.438623 msecs"

Criterium reports:

reduce   144 ms
r/fold    72 ms

---

Update #2

Rich Hickey talked about the design of transducers/reducers at the 2014 Clojure Conj . You may find these details useful. The basic idea is that the folding is delegated to each collection type, which uses knowledge of its implementation details to perform the fold efficiently.

Since hash-maps use a vector internally, they can fold in parallel efficiently.

Answer 2

There is this talk by Guy Steele which predates reducers and might just have served as an inspiration for them. https://vimeo.com/6624203