Hey Lee,
I would second Jozef's suggestion that you look into using the reducers
library when you need non-lazy sequence operations. Although a major
motivation of Rich's work was clearly to enable easy parallel folding via
fork/join, the fold function is only one of many in this library. Think
instead that the main (philosophical) purpose of reducers is to decomplect
the reducing operation from the data representation it is acting on. And of
course, since reduce can be used to implement (virtually) any non-lazy
sequence operation, it stands to reason that reducers should be fully
capable of providing new implementations of many of these functions on top
of reduce (which it does).
Importantly, whenever you will be chaining sequence operations together,
reducers should be more efficient than both the lazy sequence functions
(e.g., map, filter) and the eager vector-returning functions (e.g., mapv,
filterv). This is because a chain of reducing functions generate no
intermediate representations.
<obligatory contrived example>
For example, let's say I wanted to sum the squares of all the even
numbers in a sequence called samples.
Using lazy functions: (reduce + (map #(* % %) (filter even? samples)))
Using non-lazy functions (reduce + (mapv #(* % %) (filterv even?
samples)))
Using reducers (aliased as r): (reduce + (r/map #(* % %) (r/filter even?
samples)))
</obligatory contrived example>
If you need to collect the results of a sequence operation in a data
structure rather than reducing them to an atomic value, simply use into
rather than reduce (since into uses reduce under the hood).
So to collect the squares of all the even numbers in the samples sequence,
just do this:
(into [] (r/map #(* % %) (r/filter even? samples)))
As just one sample point, when I updated a statistical fire analysis
algorithm that I wrote from using the lazy sequence functions to using the
reducers library, I experience a full order of magnitude speedup. This sped
up my runtime from ~6 hours to around 20 minutes. So please do yourself a
favor and give this library a close look. It has made worlds of difference
for some of my work.
Good luck,
~Gary
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
