CrossClj

0.7.9 docs

SourceDocs



RECENT
    VARS
    ->FToChanExc
    <!
    <!!
    >!
    >!!
    admix
    alt!
    alt!!
    alts!
    alts!!
    bounded-count
    buffer
    chan
    close!
    do-alts
    do-alts-internal
    dropping-buffer
    ex-handler
    f-to-chan
    fiber
    fiber-call
    go
    go-loop
    into
    last
    map
    map->FToChanExc
    merge
    Mix
    mix
    Mult
    mult
    Mux
    onto-chan
    pipe
    pipeline
    pipeline*
    pipeline-async
    pipeline-blocking
    Pub
    pub
    put!
    reduce
    rx-chan
    sliding-buffer
    solo-mode
    split
    sub
    take
    take!
    tap
    thread
    thread-call
    thread-macro-executor
    timeout
    to-chan
    toggle
    unblocking-buffer?
    unmix
    unmix-all
    unsub
    unsub-all
    untap
    untap-all

    « Index of all namespaces of this project

    Fiber-based implementation of [org.clojure/core.async "0.1.346.0-17112a-alpha"]
    
    Private
    (->FToChanExc exc)
    Positional factory function for class co.paralleluniverse.pulsar.async.FToChanExc.
    
    (<! port)
    Takes a val from port. Must be called inside a (go ...) block. Will
    return nil if closed. Will park if nothing is available.
    
    Pulsar implementation: Identical to <!!. May be used outside go blocks as well.
    Takes a val from port. Will return nil if closed. Will block
    if nothing is available.
    
    Pulsar implementation: Identical to <!. May be used outside go blocks as well.
    (>! 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.
    
    Pulsar implementation: Identical to >!!. May be used outside go blocks as well.
    Puts a val into port. nil values are not allowed. Will block if no
    buffer space is available. Returns true unless port is already closed.
    
    Pulsar implementation: Identical to >!. May be used outside go blocks as well.
    (admix mix ch)
    Adds ch as an input to the mix
    
    macro
    (alt! & clauses)
    Makes a single choice between one of several channel operations,
    as if by alts!, returning the value of the result expr corresponding
    to the operation completed. Must be called inside a (go ...) block.
    
    Each clause takes the form of:
    
    channel-op[s] result-expr
    
    where channel-ops is one of:
    
    take-port - a single port to take
    [take-port | [put-port put-val] ...] - a vector of ports as per alts!
    :default | :priority - an option for alts!
    
    and result-expr is either a list beginning with a vector, whereupon that
    vector will be treated as a binding for the [val port] return of the
    operation, else any other expression.
    
    (alt!
    [c t] ([val ch] (foo ch val))
    x ([v] v)
    [[out val]] :wrote
    :default 42)
    
    Each option may appear at most once. The choice and parking
    characteristics are those of alts!.
    
    Pulsar implementation: Identical to alt!!. May be used outside go blocks as well.
    macro
    (alt!! & args)
    Like alt!, except as if by alts!!, will block until completed, and
    not intended for use in (go ...) blocks.
    
    Pulsar implementation: identical to alt! and may be
    used in go blocks
    (alts! ports & {:as opts})
    Completes at most one of several channel operations. Must be called
    inside a (go ...) block. ports is a set 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 nil 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.
    
    Pulsar implementation: Identical to alts!!. May be used outside go blocks as well.
    macro
    (alts!! & args)
    Like alts!, except takes will be made as if by <!!, and puts will
    be made as if by >!!, will block until completed, and not intended
    for use in (go ...) blocks.
    
    Pulsar implementation: identical to alt! and may be
    used in go blocks
    Private
    (bounded-count n coll)
    Returns the smaller of n or the count of coll, without examining
    more than n items if coll is not counted
    (buffer n)
    Returns a fixed buffer of size n. When full, puts will block/park.
    
    (chan)(chan buf-or-n)(chan buf-or-n xform)(chan buf-or-n xform ex-handler)
    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 Throwable as an argument, and any non-nil return value will be
    placed in the channel.
    (close! chan)
    Closes a channel. The channel will no longer accept any puts (they
    will be ignored). Data in the channel remains available for taking, until
    exhausted, after which takes will return nil. If there are any
    pending takes, they will be dispatched with nil. Closing a closed
    channel is a no-op. Returns nil.
    (do-alts fret ports opts)
    Returns derefable [val port] if immediate, nil if enqueued
    
    Private
    (do-alts-internal ports opts)
    Returns a SelectAction given a set of selection operations and an options map
    
    (dropping-buffer n)
    Returns a buffer of size n. When full, puts will complete but
    val will be dropped (no transfer).
    Private
    (ex-handler ex)
    Private
    (f-to-chan c f)
    macro
    (fiber & body)
    Executes the body in another fiber, returning immediately to the
    calling strand. Returns a channel which will receive the result of
    the body when completed.
    (fiber-call f)
    Executes f in another fiber, returning immediately to the calling
    strand. Returns a channel which will receive the result of calling
    f when completed.
    macro
    (go & body)
    Asynchronously executes the body, returning immediately to the
    calling thread. Additionally, any visible calls to <!, >! and alt!/alts!
    channel operations within the body will block (if necessary) by
    'parking' the calling thread rather than tying up an OS thread (or
    the only JS thread when in ClojureScript). Upon completion of the
    operation, the body will be resumed.
    
    Returns a channel which will receive the result of the body when
    completed
    macro
    (go-loop bindings & body)
    Like (go (loop ...))
    
    (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.
    Private
    (last ch)
    (map f chs)(map f chs buf-or-n)
    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
    Private
    (map->FToChanExc m__7585__auto__)
    Factory function for class co.paralleluniverse.pulsar.async.FToChanExc, taking a map of keywords to field values.
    
    (merge chs)(merge chs buf-or-n)
    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.
    protocol
    (admix* m ch)
    (solo-mode* m mode)
    (toggle* m state-map)
    (unmix* m ch)
    (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
    (tap* m ch close?)
    (untap* m ch)
    (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.
    (onto-chan ch coll)(onto-chan ch coll close?)
    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.
    (pipe from to)(pipe from to close?)
    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 n to xf from)(pipeline n to xf from close?)(pipeline n to xf from close? ex-handler)
    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
    should be used for computational parallelism. If you have multiple
    blocking operations to put in flight, use pipeline-blocking instead,
    If you have multiple asynchronous operations to put in flight, use
    pipeline-async instead.
    Private
    (pipeline* n to xf from close? ex-handler type)
    (pipeline-async n to af from)(pipeline-async n to af from close?)
    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
    (i.e. in another strand) 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. See also
    pipeline, pipeline-blocking.
    (pipeline-blocking n to xf from)(pipeline-blocking n to xf from close?)(pipeline-blocking n to xf from close? ex-handler)
    Like pipeline, for blocking operations.
    
    protocol
    (sub* p v ch close?)
    (unsub* p v ch)
    (unsub-all* p)(unsub-all* p v)
    (pub ch topic-fn)(pub ch topic-fn buf-fn)
    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! port val)(put! port val fn1)(put! port val fn1 on-caller?)
    Asynchronously puts a val into port, calling fn1 (if supplied) when
    complete, passing false iff port is already closed. nil values are
    not allowed. If on-caller? (default true) is true, and the put is
    immediately accepted, will call fn1 on calling thread.  Returns
    true unless port is already closed.
    (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.
    (rx-chan chan xform exh)
    (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 p ch)(split p ch t-buf-or-n f-buf-or-n)
    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 p topic ch)(sub p topic ch close?)
    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 n ch)(take n ch buf-or-n)
    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 channel will close.
    
    The output channel is unbuffered by default, unless buf-or-n is given.
    (take! port fn1)(take! port fn1 on-caller?)
    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 mult ch)(tap mult ch close?)
    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.
    macro
    (thread & body)
    Executes the body in another thread, returning immediately to the
    calling thread. Returns a channel which will receive the result of
    the body when completed.
    (thread-call f)
    Executes f in another thread, returning immediately to the calling
    thread. Returns a channel which will receive the result of calling
    f when completed.
    (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? [_ policy])
    Returns true if a channel created with buffer will never block. That is to say,
    puts into this buffer will never cause the buffer to be full. 
    (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 p)(unsub-all p topic)
    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