CrossClj

4.1.0 docs

SourceDocs



RECENT
    VARS
    aref->disposable
    aref->subscription
    as-action
    as-backpressure-strategy
    as-bifunction
    as-consumer
    as-function
    as-predicate
    behavior-subject
    buffer
    buffer-time
    cancel!
    catch
    combine-latest
    concat
    connect!
    create
    debounce
    dedupe
    dedupe'
    delay
    delay-when
    disposable-atom
    disposable?
    do
    empty
    end
    end!
    error!
    filter
    flat-map
    flowable?
    from-atom
    from-coll
    from-future
    from-publisher
    generate
    ICancellable
    ignore
    interval
    IObservableValue
    ISubscriber
    ISubscription
    just
    log
    map
    mapcat
    merge
    merge-map
    never
    noop
    noop-action
    noop-consumer
    observable?
    observe-on
    observer?
    of
    on-complete
    on-end
    on-error
    on-next
    on-value
    once
    pr-log
    publish
    push!
    race
    range
    reduce
    request!
    retry
    sample
    sample-when
    scan
    scheduler
    scheduler?
    share
    single?
    skip
    skip-until
    skip-while
    subject
    subject?
    subscribe
    subscribe-flowable-with-isubscriber
    subscribe-observable-with-isubscriber
    subscribe-on
    subscribe-to-flowable
    subscribe-to-observable
    subscribe-with
    subscribe-with-observer
    take
    take-until
    take-while
    tap
    throttle
    throw
    timeout
    timer
    to-atom
    to-flowable
    to-serialized
    transform
    unwrap-composite-exception
    with-latest
    wrap-disposable
    zip

    « Index of all namespaces of this project

    Private
    (aref->disposable ref)
    Private
    (aref->subscription ref)
    (as-action f)
    Wrap the provided function into a Action instance.
    
    Private
    (as-backpressure-strategy strategy)
    (as-bifunction f)
    Wrap the provided function into a Function instance.
    
    (as-consumer f)
    Wrap the provided function into a Consumer instance.
    
    (as-function f)
    Wrap the provided function into a Function instance.
    
    (as-predicate f)
    Wrap the provided function into a Predicate instance.
    
    (behavior-subject v)
    Bus that emits the most recent item it has observed and
    all subsequent observed items to each subscribed Observer.
    (buffer n ob)(buffer n skip ob)
    Projects each element of an observable sequence into zero
    or more buffers which are produced based on element count
    information.
    (buffer-time ms ob)
    Buffers the source Observable values for a specific time period.
    
    (cancel! v)
    Dispose resources acquired by the subscription.
    
    (catch handler ob)(catch pred handler ob)
    Continues an observable sequence that is terminated
    by an exception with the next observable sequence.
    (combine-latest other ob)(combine-latest f other ob)
    Combines multiple Observables to create an Observable
    whose values are calculated from the latest values of
    each of its input Observables.
    (concat & more)
    Concatenates all of the specified observable
    sequences, as long as the previous observable
    sequence terminated successfully.
    (connect! ob)
    Connect the connectable observable.
    
    (create factory)
    Creates an observable sequence from a specified
    subscribe method implementation.
    (debounce ms ob)
    Emits an item from the source Observable after a
    particular timespan has passed without the Observable
    omitting any other items.
    (dedupe ob)(dedupe f ob)
    Returns an observable sequence that contains only
    distinct contiguous elements.
    (dedupe' ob)(dedupe' f ob)
    Returns an observable sequence that contains only d
    istinct elements.
    Usage of this operator should be considered carefully
    due to the maintenance of an internal lookup structure
    which can grow large.
    (delay ms ob)
    Time shifts the observable sequence by dueTime. The relative
    time intervals between the values are preserved.
    (delay-when sf ob)(delay-when sd sf ob)
    Time shifts the observable sequence based on a subscription
    delay and a delay selector function for each element.
    Private
    (disposable-atom ref disposable)
    (disposable? v)
    Check if the provided object is disposable (jvm) or subscription (js).
    
    An idiomatic alias for tap.
    
    (empty)
    Returns an observable sequence that is already
    in end state.
    Mark a value as a final value of the stream.
    
    (end! b)
    Ends the given bus stream.
    
    (error! b e)
    Pushes the given error to the bus stream.
    
    (filter f ob)
    Filters the elements of an observable sequence
    based on a predicate.
    (flat-map ob)(flat-map f ob)
    Projects each element of an observable sequence to
    an observable sequence and merges the resulting
    observable sequences or Promises or array/iterable
    into one observable sequence.
    (flowable? o)
    Check if the provided value is Flowable instance.
    
    (from-atom atm)
    (from-coll coll)
    Generates an observable sequence from collection.
    
    (from-future p)
    Creates an observable from a future.
    
    (from-publisher v)
    Converts an arbitrary Reactive-Streams Publisher into a
    Flowable if not already a Flowable.
    (generate next)(generate next setup)(generate next setup dispose)
    Returns a cold, synchronous, stateful and backpressure-aware
    generator of values.
    protocol
    (-cancel _)
    dispose resources.
    
    (ignore ob)
    Ignores all elements in an observable sequence leaving
    only the termination messages.
    (interval ms)
    Returns an observable sequence that produces a
    value after each period.
    protocol
    (-end? _)
    Returns true if is end value.
    
    (-error? _)
    Returns true if is end value.
    
    (-next? _)
    Returns true if is end value.
    
    protocol
    Backpressure aware subscriber abstraction.
    
    (-on-end _)
    Subscription termination notification hook.
    
    (-on-error _ error)
    Subscription error notification hook.
    
    (-on-init _ s)
    Subscription initialization hook.
    
    (-on-next _ s value)
    Subscription data notification hook.
    
    protocol
    (-request _ n)
    request 1 or n items to the subscription.
    
    (just v)
    Returns an observable sequence that contains
    a single element.
    (log ob)(log prefix ob)
    Print all values passed through the given
    observable sequence.
    (map f ob)
    Apply a function to each element of an observable
    sequence.
    (mapcat f ob)
    Projects each element of an observable sequence to an observable
    sequence and concatenates the resulting observable sequences or
    Promises or array/iterable into one observable sequence.
    (merge & more)
    Merges all the observable sequences and Promises
    into a single observable sequence.
    An idiomatic alias for flat-map.
    
    Alias to 'empty'.
    
    (observable? ob)
    Return true if ob is a instance
    of Rx.Observable.
    (observe-on schd ob)
    (observer? o)
    Check if the provided value is Observer instance.
    
    (of a)(of a b)(of a b c)(of a b c d)(of a b c d e)(of a b c d e f)(of a b c d e f & more)
    Converts arguments to an observable sequence.
    
    A semantic alias for on-end.
    
    (on-end ob f)
    Subscribes a function to invoke upon graceful termination
    of the observable sequence.
    (on-error ob f)
    Subscribes a function to invoke upon exceptional termination
    of the observable sequence.
    A semantic alias for on-value.
    
    (on-value ob f)
    Subscribes a function to invoke for each element
    in the observable sequence.
    (once v)
    An alias to just.
    
    (pr-log ob)(pr-log prefix ob)
    Print all values passed through the given
    observable sequence using pr-str.
    (publish ob)
    Create a connectable (hot) observable
    from other observable.
    (push! b v)
    Pushes the given value to the bus stream.
    
    (race a b)(race a b & more)
    Create an observable that surfaces any of the given
    sequences, whichever reacted first.
    (range b)(range a b)
    Generates an observable sequence that repeats the
    given element.
    (reduce f ob)(reduce f seed ob)
    Applies an accumulator function over an observable
    sequence, returning the result of the aggregation as a
    single element in the result sequence.
    (request! s n)
    (retry ob)(retry n ob)
    Given an optional number of retries and an observable,
    repeats the source observable the specified number of
    times or until it terminates. If no number of retries
    is given, it will be retried indefinitely.
    (sample ms ob)
    Samples the observable sequence at each interval.
    
    (sample-when other ob)
    Samples the observable sequence at each interval.
    
    (scan f ob)(scan f seed ob)
    Applies an accumulator function over an observable
    sequence and returns each intermediate result.
    Same as reduce but with intermediate results
    (scheduler type)
    Get the scheduler instance by type. The possible
    types are: :computation, :io, :single,
    :thread and :trampoline.
    (scheduler? v)
    Check if the provided value is Scheduler instance.
    
    (share ob)
    Returns an observable sequence that shares a single
    subscription to the underlying sequence.
    (single? o)
    Check if the provided value is Single instance.
    
    (skip n ob)
    Bypasses a specified number of elements in an
    observable sequence and then returns the remaining
    elements.
    (skip-until pob ob)
    Returns the values from the source observable sequence
    only after the other observable sequence produces a value.
    (skip-while f ob)
    Bypasses elements in an observable sequence as long
    as a specified condition is true and then returns the
    remaining elements.
    (subject)
    Subject that, once an Observer has subscribed, emits all
    subsequently observed items to the subscriber.
    (subject? b)
    Check if the provided value is Subject instance.
    
    (subscribe ob nf)(subscribe ob nf ef)(subscribe ob nf ef cf)(subscribe ob nf ef cf sf)
    Subscribes an observer to the observable sequence.
    
    Private
    (subscribe-flowable-with-isubscriber ob subscriber)
    Private
    (subscribe-observable-with-isubscriber ob subscriber)
    (subscribe-on schd ob)
    Private
    (subscribe-to-flowable ob nf ef cf sf)
    Private
    (subscribe-to-observable ob nf ef cf sf)
    (subscribe-with ob subscriber)
    Subscribes an observer or subscriber to the observable/flowable sequence.
    
    Private
    (subscribe-with-observer ob observer)
    (take n ob)
    Bypasses a specified number of elements in an
    observable sequence and then returns the remaining
    elements.
    (take-until other ob)
    Returns the values from the source observable sequence until
    the other observable sequence or Promise produces a value.
    (take-while f ob)
    Returns elements from an observable sequence as long as a
    specified predicate returns true.
    (tap f ob)(tap f g ob)(tap f g e ob)
    Invokes an action for each element in the
    observable sequence.
    (throttle ms ob)
    Returns an observable sequence that emits only the
    first item emitted by the source Observable during
    sequential time windows of a specified duration.
    (timeout ms ob)(timeout ms other ob)
    Returns the source observable sequence or the other
    observable sequence if dueTime elapses.
    (timer delay)(timer delay period)
    Returns an observable sequence that produces a value after
    ms has elapsed and then after each period.
    (to-atom ob)(to-atom ob a)(to-atom ob a f)
    Materialize the observable sequence into an atom.
    
    (to-flowable ob)(to-flowable strategy ob)
    Convert an observable into backpressure-aware Flowable instance.
    
    (to-serialized s)
    Converts an Subject into a Serialized Subject if not
    already Serialized.
    (transform xform stream)
    Transform the observable sequence using transducers.
    
    Private
    (unwrap-composite-exception exc)
    (with-latest f other source)
    Merges the specified observable sequences into
    one observable sequence by using the selector
    function only when the source observable sequence
    (the instance) produces an element.
    Private
    (wrap-disposable disposable)
    (zip & items)
    Merges the specified observable sequences or Promises
    into one observable sequence.