CrossClj

1.10.0-alpha4 docs

SourceDocs



RECENT
    VARS
    binary-op
    binary-predicate
    int-and-object-predicate
    int-and-object-to-object
    op
    pa-to-vec
    pall
    pany
    par
    pcumulate
    pdistinct
    pfilter-dupes
    pfilter-nils
    pmax
    pmin
    predicate
    preduce
    psort
    psummary
    pvec
    reducer
    summary-map

    « Index of all namespaces of this project

    DEPRECATED Wrapper of the ForkJoin library (JSR-166).
    

    — Rich Hickey

    Private
    (binary-op f)
    Private
    (binary-predicate f)
    Private
    (int-and-object-predicate f)
    Private
    (int-and-object-to-object f)
    Private
    (op f)
    Private
    (pa-to-vec pa)
    Private
    (pall coll)
    Realizes a copy of the coll as a parallel array, with any bounds/filters/maps applied
    
    (pany coll)
    Returns some (random) element of the coll if it satisfies the bound/filter/map
    
    (par coll)(par coll & ops)
    Creates a parallel array from coll. ops, if supplied, perform
    on-the-fly filtering or transformations during parallel realization
    or calculation. ops form a chain, and bounds must precede filters,
    must precede maps. ops must be a set of keyword value pairs of the
    following forms:
    
       :bound [start end] 
    
    Only elements from start (inclusive) to end (exclusive) will be
    processed when the array is realized.
    
       :filter pred 
    
    Filter preds remove elements from processing when the array is realized. pred
    must be a function of one argument whose return will be processed
    via boolean.
    
       :filter-index pred2 
    
    pred2 must be a function of two arguments, which will be an element
    of the collection and the corresponding index, whose return will be
    processed via boolean.
    
       :filter-with [pred2 coll2] 
    
    pred2 must be a function of two arguments, which will be
    corresponding elements of the 2 collections.
    
       :map f 
    
    Map fns will be used to transform elements when the array is
    realized. f must be a function of one argument.
    
       :map-index f2 
    
    f2 must be a function of two arguments, which will be an element of
    the collection and the corresponding index.
    
       :map-with [f2 coll2]
    
    f2 must be a function of two arguments, which will be corresponding
    elements of the 2 collections.
    Private
    (pcumulate coll f init)
    (pdistinct coll)
    Returns a parallel array of the distinct elements of coll
    
    (pfilter-dupes coll)
    Returns a vector containing the (realized) elements of coll, 
    without any consecutive duplicates
    (pfilter-nils coll)
    Returns a vector containing the non-nil (realized) elements of coll
    
    (pmax coll)(pmax coll comp)
    Returns the maximum element, presuming Comparable elements, unless
    a Comparator comp is supplied
    (pmin coll)(pmin coll comp)
    Returns the minimum element, presuming Comparable elements, unless
    a Comparator comp is supplied
    Private
    (predicate f)
    (preduce f base coll)
    Returns the reduction of the realized elements of coll
    using function f. Note f will not necessarily be called
    consecutively, and so must be commutative. Also note that 
    (f base an-element) might be performed many times, i.e. base is not
    an initial value as with sequential reduce.
    (psort coll)(psort coll comp)
    Returns a new vector consisting of the realized items in coll, sorted, 
    presuming Comparable elements, unless a Comparator comp is supplied
    (psummary coll)(psummary coll comp)
    Returns a map of summary statistics (min. max, size, min-index, max-index, 
    presuming Comparable elements, unless a Comparator comp is supplied
    (pvec pa)
    Returns the realized contents of the parallel array pa as a Clojure vector
    
    Private
    (reducer f)
    Private
    (summary-map s)