CrossClj

0.0.1 docs

SourceDocs



RECENT
    VARS
    <!
    >!
    admix
    alt-flag
    alt-handler
    alts!
    buffer
    chan
    close!
    do-alts
    dropping-buffer
    fhnop
    filter<
    filter>
    fn-handler
    into
    ioc-alts!
    map
    map<
    map>
    mapcat*
    mapcat<
    mapcat>
    merge
    mix
    Mix
    Mult
    mult
    Mux
    nop
    offer!
    onto-chan
    partition
    partition-by
    pipe
    pipeline
    pipeline*
    pipeline-async
    poll!
    promise-chan
    Pub
    pub
    put!
    random-array
    reduce
    remove<
    remove>
    sliding-buffer
    solo-mode
    split
    sub
    take
    take!
    tap
    timeout
    to-chan
    toggle
    unblocking-buffer?
    unique
    unmix
    unmix-all
    unsub
    unsub-all
    untap
    untap-all

    « Index of all namespaces of this project

    (<! port)
    takes a val from port. Must be called inside a (go ...) block. Will
    return nil if closed. Will park if nothing is available.
    Returns true unless port is already closed
    (>! port val)
    puts a val into port. nil values are not allowed. Must be called
    inside a (go ...) block. Will park if no buffer space is available.
    Returns true unless port is already closed.
    (admix mix ch)
    Adds ch as an input to the mix
    
    Private
    (alt-flag)
    Private
    (alt-handler flag cb)
    (alts! ports & {:as opts})
    Completes at most one of several channel operations. Must be called
     inside a (go ...) block. ports is a vector of channel endpoints,
     which can be either a channel to take from or a vector of
    [channel-to-put-to val-to-put], in any combination. Takes will be
    made as if by <!, and puts will be made as if by >!. Unless
    the :priority option is true, if more than one port operation is
    ready a non-deterministic choice will be made. If no operation is
    ready and a :default value is supplied, [default-val :default] will
    be returned, otherwise alts! will park until the first operation to
    become ready completes. Returns [val port] of the completed
    operation, where val is the value taken for takes, and a
    boolean (true unless already closed, as per put!) for puts.
    
    opts are passed as :key val ... Supported options:
    
    :default val - the value to use if none of the operations are immediately ready
    :priority true - (default nil) when true, the operations will be tried in order.
    
    Note: there is no guarantee that the port exps or val exprs will be
    used, nor in what order should they be, so they should not be
    depended upon for side effects.
    (buffer n)
    Returns a fixed buffer of size n. When full, puts will block/park.
    
    (chan ???)
    Creates a channel with an optional buffer, an optional transducer (like (map f),
    (filter p) etc or a composition thereof), and an optional exception handler.
    If buf-or-n is a number, will create and use a fixed buffer of that size. If a
    transducer is supplied a buffer must be specified. ex-handler must be a
    fn of one argument - if an exception occurs during transformation it will be called
    with the thrown value as an argument, and any non-nil return value will be placed
    in the channel.
    (close! port)
    (do-alts fret ports opts)
    returns derefable [val port] if immediate, nil if enqueued
    
    (dropping-buffer n)
    Returns a buffer of size n. When full, puts will complete but
    val will be dropped (no transfer).
    (filter< ???)(filter< ???)(filter< ???)
    Deprecated - this function will be removed. Use transducer instead
    
    (filter> p ch)
    Deprecated - this function will be removed. Use transducer instead
    
    Private
    (fn-handler ???)(fn-handler ???)
    (into coll ch)
    Returns a channel containing the single (collection) result of the
    items taken from the channel conjoined to the supplied
    collection. ch must close before into produces a result.
    (ioc-alts! state cont-block ports & {:as opts})
    (map ???)(map ???)(map ???)
    Takes a function and a collection of source channels, and returns a
    channel which contains the values produced by applying f to the set
    of first items taken from each source channel, followed by applying
    f to the set of second items from each channel, until any one of the
    channels is closed, at which point the output channel will be
    closed. The returned channel will be unbuffered by default, or a
    buf-or-n can be supplied
    (map< f ch)
    Deprecated - this function will be removed. Use transducer instead
    
    (map> f ch)
    Deprecated - this function will be removed. Use transducer instead
    
    Private
    (mapcat* f in out)
    (mapcat< ???)(mapcat< ???)(mapcat< ???)
    Deprecated - this function will be removed. Use transducer instead
    
    (mapcat> ???)(mapcat> ???)(mapcat> ???)
    Deprecated - this function will be removed. Use transducer instead
    
    (merge ???)(merge ???)
    Takes a collection of source channels and returns a channel which
    contains all values taken from them. The returned channel will be
    unbuffered by default, or a buf-or-n can be supplied. The channel
    will close after all the source channels have closed.
    (mix out)
    Creates and returns a mix of one or more input channels which will
    be put on the supplied out channel. Input sources can be added to
    the mix with 'admix', and removed with 'unmix'. A mix supports
    soloing, muting and pausing multiple inputs atomically using
    'toggle', and can solo using either muting or pausing as determined
    by 'solo-mode'.
    
    Each channel can have zero or more boolean modes set via 'toggle':
    
    :solo - when true, only this (ond other soloed) channel(s) will appear
            in the mix output channel. :mute and :pause states of soloed
            channels are ignored. If solo-mode is :mute, non-soloed
            channels are muted, if :pause, non-soloed channels are
            paused.
    
    :mute - muted channels will have their contents consumed but not included in the mix
    :pause - paused channels will not have their contents consumed (and thus also not included in the mix)
    protocol
    (admix* m ch)
    (unmix* m ch)
    (solo-mode* m mode)
    (toggle* m state-map)
    protocol
    (untap* m ch)
    (tap* m ch close?)
    (mult ch)
    Creates and returns a mult(iple) of the supplied channel. Channels
    containing copies of the channel can be created with 'tap', and
    detached with 'untap'.
    
    Each item is distributed to all taps in parallel and synchronously,
    i.e. each tap must accept before the next item is distributed. Use
    buffering/windowing to prevent slow taps from holding up the mult.
    
    Items received when there are no taps get dropped.
    
    If a tap puts to a closed channel, it will be removed from the mult.
    Private
    (nop _)
    (offer! port val)
    Puts a val into port if it's possible to do so immediately.
    nil values are not allowed. Never blocks. Returns true if offer succeeds.
    (onto-chan ???)(onto-chan ???)(onto-chan ???)
    Puts the contents of coll into the supplied channel.
    
    By default the channel will be closed after the items are copied,
    but can be determined by the close? parameter.
    
    Returns a channel which will close after the items are copied.
    (partition ???)(partition ???)(partition ???)
    Deprecated - this function will be removed. Use transducer instead
    
    (partition-by ???)(partition-by ???)(partition-by ???)
    Deprecated - this function will be removed. Use transducer instead
    
    (pipe ???)(pipe ???)(pipe ???)
    Takes elements from the from channel and supplies them to the to
    channel. By default, the to channel will be closed when the from
    channel closes, but can be determined by the close?  parameter. Will
    stop consuming the from channel if the to channel closes
    (pipeline ???)(pipeline ???)(pipeline ???)(pipeline ???)(pipeline ???)
    Takes elements from the from channel and supplies them to the to
    channel, subject to the transducer xf, with parallelism n. Because
    it is parallel, the transducer will be applied independently to each
    element, not across elements, and may produce zero or more outputs
    per input.  Outputs will be returned in order relative to the
    inputs. By default, the to channel will be closed when the from
    channel closes, but can be determined by the close?  parameter. Will
    stop consuming the from channel if the to channel closes.
    
    Note this is supplied for API compatibility with the Clojure version.
    Values of N > 1 will not result in actual concurrency in a
    single-threaded runtime.
    Private
    (pipeline* n to xf from close? ex-handler type)
    (pipeline-async ???)(pipeline-async ???)(pipeline-async ???)(pipeline-async ???)(pipeline-async ???)
    Takes elements from the from channel and supplies them to the to
    channel, subject to the async function af, with parallelism n. af
    must be a function of two arguments, the first an input value and
    the second a channel on which to place the result(s). af must close!
    the channel before returning.  The presumption is that af will
    return immediately, having launched some asynchronous operation
    whose completion/callback will manipulate the result channel. Outputs
    will be returned in order relative to  the inputs. By default, the to
    channel will be closed when the from channel closes, but can be
    determined by the close?  parameter. Will stop consuming the from
    channel if the to channel closes.
    (poll! port)
    Takes a val from port if it's possible to do so immediately.
    Never blocks. Returns value if successful, nil otherwise.
    (promise-chan ???)
    Creates a promise channel with an optional transducer, and an optional
    exception-handler. A promise channel can take exactly one value that consumers
    will receive. Once full, puts complete but val is dropped (no transfer).
    Consumers will block until either a value is placed in the channel or the
    channel is closed. See chan for the semantics of xform and ex-handler.
    protocol
    (unsub* p v ch)
    (unsub-all* ???)(unsub-all* ???)
    (sub* p v ch close?)
    (pub ???)(pub ???)(pub ???)
    Creates and returns a pub(lication) of the supplied channel,
    partitioned into topics by the topic-fn. topic-fn will be applied to
    each value on the channel and the result will determine the 'topic'
    on which that value will be put. Channels can be subscribed to
    receive copies of topics using 'sub', and unsubscribed using
    'unsub'. Each topic will be handled by an internal mult on a
    dedicated channel. By default these internal channels are
    unbuffered, but a buf-fn can be supplied which, given a topic,
    creates a buffer with desired properties.
    
    Each item is distributed to all subs in parallel and synchronously,
    i.e. each sub must accept before the next item is distributed. Use
    buffering/windowing to prevent slow subs from holding up the pub.
    
    Items received when there are no matching subs get dropped.
    
    Note that if buf-fns are used then each topic is handled
    asynchronously, i.e. if a channel is subscribed to more than one
    topic it should not expect them to be interleaved identically with
    the source.
    (put! ???)(put! ???)(put! ???)
    Asynchronously puts a val into port, calling fn0 (if supplied) when
    complete. nil values are not allowed. Will throw if closed. If
    on-caller? (default true) is true, and the put is immediately
    accepted, will call fn0 on calling thread.  Returns nil.
    Private
    (random-array n)
    (reduce f init ch)
    f should be a function of 2 arguments. Returns a channel containing
    the single result of applying f to init and the first item from the
    channel, then applying f to that result and the 2nd item, etc. If
    the channel closes without yielding items, returns init and f is not
    called. ch must close before reduce produces a result.
    (remove< ???)(remove< ???)(remove< ???)
    Deprecated - this function will be removed. Use transducer instead
    
    (remove> p ch)
    Deprecated - this function will be removed. Use transducer instead
    
    (sliding-buffer n)
    Returns a buffer of size n. When full, puts will complete, and be
    buffered, but oldest elements in buffer will be dropped (not
    transferred).
    (solo-mode mix mode)
    Sets the solo mode of the mix. mode must be one of :mute or :pause
    
    (split ???)(split ???)(split ???)(split ???)
    Takes a predicate and a source channel and returns a vector of two
    channels, the first of which will contain the values for which the
    predicate returned true, the second those for which it returned
    false.
    
    The out channels will be unbuffered by default, or two buf-or-ns can
    be supplied. The channels will close after the source channel has
    closed.
    (sub ???)(sub ???)(sub ???)(sub ???)
    Subscribes a channel to a topic of a pub.
    
    By default the channel will be closed when the source closes,
    but can be determined by the close? parameter.
    (take ???)(take ???)(take ???)
    Returns a channel that will return, at most, n items from ch. After n items
     have been returned, or ch has been closed, the return chanel will close.
    
    The output channel is unbuffered by default, unless buf-or-n is given.
    (take! ???)(take! ???)(take! ???)
    Asynchronously takes a val from port, passing to fn1. Will pass nil
    if closed. If on-caller? (default true) is true, and value is
    immediately available, will call fn1 on calling thread.
    Returns nil.
    (tap ???)(tap ???)(tap ???)
    Copies the mult source onto the supplied channel.
    
    By default the channel will be closed when the source closes,
    but can be determined by the close? parameter.
    (timeout msecs)
    Returns a channel that will close after msecs
    
    (to-chan coll)
    Creates and returns a channel which contains the contents of coll,
    closing when exhausted.
    (toggle mix state-map)
    Atomically sets the state(s) of one or more channels in a mix. The
    state map is a map of channels -> channel-state-map. A
    channel-state-map is a map of attrs -> boolean, where attr is one or
    more of :mute, :pause or :solo. Any states supplied are merged with
    the current state.
    
    Note that channels can be added to a mix via toggle, which can be
    used to add channels in a particular (e.g. paused) state.
    (unblocking-buffer? buff)
    Returns true if a channel created with buff will never block. That is to say,
    puts into this buffer will never cause the buffer to be full. 
    (unique ???)(unique ???)
    Deprecated - this function will be removed. Use transducer instead
    
    (unmix mix ch)
    Removes ch as an input to the mix
    
    (unmix-all mix)
    removes all inputs from the mix
    
    (unsub p topic ch)
    Unsubscribes a channel from a topic of a pub
    
    (unsub-all ???)(unsub-all ???)
    Unsubscribes all channels from a pub, or a topic of a pub
    
    (untap mult ch)
    Disconnects a target channel from a mult
    
    (untap-all mult)
    Disconnects all target channels from a mult