Table of Contents

fill-queue

Usage: (fill-queue filler-func & optseq)

filler-func will be called in another thread with a single arg
'fill'.  filler-func may call fill repeatedly with one arg each
time which will be pushed onto a queue, blocking if needed until
this is possible.  fill-queue will return a lazy seq of the values
filler-func has pushed onto the queue, blocking if needed until each
next element becomes available.  filler-func's return value is ignored.

find-first

Usage: (find-first pred coll)

Returns the first item of coll for which (pred item) returns logical true.
Consumes sequences up to the first match, will consume the entire sequence
and return nil if no match is found.

flatten

Usage: (flatten x)

Takes any nested combination of sequential things (lists, vectors,
etc.) and returns their contents as a single, flat sequence.
(flatten nil) returns nil.

frequencies

Usage: (frequencies coll)

Returns a map from distinct items in coll to the number of times
they appear.

group-by

Usage: (group-by f coll)

Returns a sorted map of the elements of coll keyed by the result of
f on each element. The value at each key will be a vector of the
corresponding elements, in the order they appeared in coll.

includes?

Usage: (includes? coll x)

Returns true if coll contains something equal (with =) to x,
in linear time.

indexed

Usage: (indexed s)

Returns a lazy sequence of [index, item] pairs, where items come
from 's' and indexes count up from zero.

(indexed '(a b c d))  =>  ([0 a] [1 b] [2 c] [3 d])

partition-all

Usage: (partition-all n coll)
       (partition-all n step coll)

Returns a lazy sequence of lists like clojure.core/partition, but may
include lists with fewer than n items at the end.

partition-by

Usage: (partition-by f coll)

Applies f to each value in coll, splitting it each time f returns
a new value.  Returns a lazy seq of lazy seqs.

positions

Usage: (positions pred coll)

Returns a lazy sequence containing the positions at which pred
is true for items in coll.

rand-elt

Usage: (rand-elt s)

Return a random element of this seq

rec-cat

Usage: (rec-cat binding-name & exprs)

Similar to lazy-cat but binds the resulting sequence to the supplied 
binding-name, allowing for recursive expressions.

rec-seq

Usage: (rec-seq binding-name & body)

Similar to lazy-seq but binds the resulting seq to the supplied 
binding-name, allowing for recursive expressions.

reductions

Usage: (reductions f coll)
       (reductions f init coll)

Returns a lazy seq of the intermediate values of the reduction (as
per reduce) of coll by f, starting with init.

rotations

Usage: (rotations x)

Returns a lazy seq of all rotations of a seq

separate

Usage: (separate f s)

Returns a vector:
[ (filter f s), (filter (complement f) s) ]

seq-on

Usage: (seq-on s)

Returns a seq on the object s. Works like the built-in seq but as
a multimethod that can have implementations for new classes and types.

shuffle

Usage: (shuffle coll)

Return a random permutation of coll