CrossClj

0.2.2 docs

SourceDocs



RECENT
    VARS
    ->Cat
    append!
    cat
    Cat
    CollFold
    drop
    filter
    fjfork
    fjinvoke
    fjjoin
    fjtask
    flatten
    fold
    foldcat
    folder
    foldvec
    map
    mapcat
    monoid
    reduce
    reducer
    remove
    take
    take-while

    « Index of all namespaces of this project

    A library for reduction and parallel folding. Alpha and subject
    to change.  Note that fold and its derivatives require
    jsr166y.jar for fork/join support. See Clojure's pom.xml for the
    dependency info.
    (->Cat cnt left right)
    (append! acc x)
    .adds x to acc and returns acc
    
    (cat)(cat ctor)(cat left right)
    A high-performance combining fn that yields the catenation of the
    reduced values. The result is reducible, foldable, seqable and
    counted, providing the identity collections are reducible, seqable
    and counted. The single argument version will build a combining fn
    with the supplied identity constructor. Tests for identity
    with (zero? (count x)). See also foldcat.
    protocol
    (coll-fold coll n combinef reducef)
    (drop n)(drop n coll)
    Elides the first n values from the reduction of coll.
    
    (filter pred)(filter pred coll)
    Retains values in the reduction of coll for which (pred val)
    returns logical true. Foldable.
    Private
    (fjfork task)
    Private
    (fjinvoke f)
    Private
    (fjjoin task)
    Private
    (fjtask f)
    (flatten)(flatten coll)
    Takes any nested combination of sequential things (lists, vectors,
    etc.) and returns their contents as a single, flat foldable
    collection.
    (fold reducef coll)(fold combinef reducef coll)(fold n combinef reducef coll)
    Reduces a collection using a (potentially parallel) reduce-combine
    strategy. The collection is partitioned into groups of approximately
    n (default 512), each of which is reduced with reducef (with a seed
    value obtained by calling (combinef) with no arguments). The results
    of these reductions are then reduced with combinef (default
    reducef). combinef must be associative, and, when called with no
    arguments, (combinef) must produce its identity element. These
    operations may be performed in parallel, but the results will
    preserve order.
    
    Note: Performing operations in parallel is currently not implemented.
    (foldcat coll)
    Equivalent to (fold cat append! coll)
    
    (folder coll xf)
    Given a foldable collection, and a transformation function xf,
    returns a foldable collection, where any supplied reducing
    fn will be transformed by xf. xf is a function of reducing fn to
    reducing fn.
    Private
    (foldvec v n combinef reducef)
    (map f)(map f coll)
    Applies f to every value in the reduction of coll. Foldable.
    
    (mapcat f)(mapcat f coll)
    Applies f to every value in the reduction of coll, concatenating the result
    colls of (f val). Foldable.
    (monoid op ctor)
    Builds a combining fn out of the supplied operator and identity
    constructor. op must be associative and ctor called with no args
    must return an identity value for it.
    (reduce f coll)(reduce f init coll)
    Like core/reduce except:
    When init is not provided, (f) is used.
    Maps are reduced with reduce-kv
    (reducer coll xf)
    Given a reducible collection, and a transformation function xf,
    returns a reducible collection, where any supplied reducing
    fn will be transformed by xf. xf is a function of reducing fn to
    reducing fn.
    (remove pred)(remove pred coll)
    Removes values in the reduction of coll for which (pred val)
    returns logical true. Foldable.
    (take n)(take n coll)
    Ends the reduction of coll after consuming n values.
    
    (take-while pred)(take-while pred coll)
    Ends the reduction of coll when (pred val) returns logical false.