beicon.core — funcool/beicon 5.1.0

as-action clj

(as-action f)

Wrap the provided function into a Action instance.

as-bifunction clj

(as-bifunction f)

Wrap the provided function into a Function instance.

as-consumer clj

(as-consumer f)

Wrap the provided function into a Consumer instance.

as-flowable clj

(as-flowable ob)

Coerce a object to an flowable instance.

as-function clj

(as-function f)

Wrap the provided function into a Function instance.

as-observable clj/s

(as-observable ob)

Coerce a object to an observable instance.

as-predicate clj

(as-predicate f)

Wrap the provided function into a Predicate instance.

behavior-subject clj/s

(behavior-subject v)

Bus that emits the most recent item it has observed and all subsequent observed items to each subscribed Observer.

BehaviorSubject cljs

buffer clj/s

(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 clj/s

(buffer-time ms ob)

Buffers the source Observable values for a specific time period.

cancel! clj/s

(cancel! v)

Dispose resources acquired by the subscription.

catch clj/s

(catch handler ob)

(catch pred handler ob)

Continues an observable sequence that is terminated by an exception with the next observable sequence.

combine-latest clj/s

(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 clj/s

(concat & more)

Concatenates all of the specified observable sequences, as long as the previous observable sequence terminated successfully.

connect! clj/s

(connect! ob)

Connect the connectable observable.

create clj/s≠

clj

(create factory)

cljs

(create sf)

Creates an observable sequence from a specified subscribe method implementation.

debounce clj/s

(debounce ms ob)

Emits an item from the source Observable after a particular timespan has passed without the Observable omitting any other items.

dedupe clj/s

(dedupe ob)

(dedupe f ob)

Returns an observable sequence that contains only distinct contiguous elements.

dedupe' clj/s

(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 clj/s

(delay ms ob)

Time shifts the observable sequence by dueTime. The relative time intervals between the values are preserved.

delay-when clj/s

(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.

Disposable cljs

disposable? clj/s

(disposable? v)

Check if the provided object is disposable (jvm) or subscription (js).

do clj/s

An idiomatic alias for tap.

empty clj/s

(empty)

Returns an observable sequence that is already in end state.

end clj/s

Mark a value as a final value of the stream.

end! clj/s

(end! b)

Ends the given bus stream.

error! clj/s

(error! b e)

Pushes the given error to the bus stream.

filter clj/s

(filter f ob)

Filters the elements of an observable sequence based on a predicate.

fjoin cljs

(fjoin & items)

Runs all observable sequences in parallel and collect their last elements.

flat-map clj/s

(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? clj

(flowable? ob)

Check if the provided value is Flowable instance.

fork-join cljs

Alias to fjoin.

from-atom clj/s

(from-atom atm)

from-coll clj/s

(from-coll coll)

Generates an observable sequence from collection.

from-event cljs

(from-event et ev)

Creates an Observable by attaching an event listener to an event target

from-future clj

(from-future p)

Creates an observable from a future.

from-promise cljs

(from-promise p)

Creates an observable from a promise.

from-publisher clj

(from-publisher v)

Converts an arbitrary Reactive-Streams Publisher into a Flowable if not already a Flowable.

generate clj

(generate next)

(generate next setup)

(generate next setup dispose)

Returns a cold, synchronous, stateful and backpressure-aware generator of values.

ICancellable clj/s≠ protocol

-cancel clj/s

(-cancel _)

dispose resources.

ignore clj/s

(ignore ob)

Ignores all elements in an observable sequence leaving only the termination messages.

interval clj/s

(interval ms)

Returns an observable sequence that produces a value after each period.

IObservableValue clj/s≠ protocol

-end? clj/s

(-end? _)

Returns true if is end value.

-error? clj/s

(-error? _)

Returns true if is end value.

-next? clj/s

(-next? _)

Returns true if is end value.

ISubscriber clj/s≠ protocol

Backpressure aware subscriber abstraction.

-on-end clj/s

(-on-end _)

Subscription termination notification hook.

-on-error clj/s

(-on-error _ error)

Subscription error notification hook.

-on-init clj/s

(-on-init _ s)

Subscription initialization hook.

-on-next clj/s

(-on-next _ s value)

Subscription data notification hook.

ISubscription clj/s≠ protocol

-request clj/s

(-request _ n)

request 1 or n items to the subscription.

just clj/s

(just v)

Returns an observable sequence that contains a single element.

log clj/s

(log ob)

(log prefix ob)

Print all values passed through the given observable sequence.

map clj/s

(map f ob)

Apply a function to each element of an observable sequence.

map-indexed clj/s

(map-indexed f ob)

mapcat clj/s

(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 clj/s

(merge & more)

Merges all the observable sequences and Promises into a single observable sequence.

merge-all cljs

(merge-all ob)

Merges an observable sequence of observable sequences into an observable sequence.

merge-map clj/s

An idiomatic alias for flat-map.

never clj/s

Alias to 'empty'.

Observable cljs

observable? clj/s

(observable? ob)

Return true if ob is a instance of Rx.Observable.

observe-on clj/s

(observe-on schd ob)

Observer cljs

observer? clj

(observer? o)

Check if the provided value is Observer instance.

of clj/s

(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.

on-complete clj/s

A semantic alias for on-end.

on-end clj/s

(on-end ob f)

Subscribes a function to invoke upon graceful termination of the observable sequence.

on-error clj/s

(on-error ob f)

Subscribes a function to invoke upon exceptional termination of the observable sequence.

on-next clj/s

A semantic alias for on-value.

on-value clj/s

(on-value ob f)

Subscribes a function to invoke for each element in the observable sequence.

once clj/s

(once v)

An alias to just.

pipe cljs

(pipe ob op)

pr-log clj/s

(pr-log ob)

(pr-log prefix ob)

Print all values passed through the given observable sequence using pr-str.

publish clj/s

(publish ob)

Create a connectable (hot) observable from other observable.

push! clj/s

(push! b v)

Pushes the given value to the bus stream.

race clj/s

(race a b)

(race a b & more)

Create an observable that surfaces any of the given sequences, whichever reacted first.

range clj/s

(range b)

(range a b)

Generates an observable sequence that repeats the given element.

reduce clj/s

(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! clj/s

(request! s n)

retry clj/s

(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.

rx cljs

rxop cljs

sample clj/s

(sample ms ob)

Samples the observable sequence at each interval.

sample-when clj/s

(sample-when other ob)

Samples the observable sequence at each interval.

scan clj/s

(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 cljs

scheduler clj/s≠

(scheduler type)

clj

Get the scheduler instance by type. The possible types are: :computation, :io, :single, :thread and :trampoline.

cljs

Get the scheduler instance by type. The posible types are: :asap, :async, :queue. Old :trampoline type is renamed as :queue and is deprecated.

scheduler? clj/s

(scheduler? v)

Check if the provided value is Scheduler instance.

share clj/s

(share ob)

Returns an observable sequence that shares a single subscription to the underlying sequence.

single? clj

(single? o)

Check if the provided value is Single instance.

skip clj/s

(skip n ob)

Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.

skip-until clj/s

(skip-until pob ob)

Returns the values from the source observable sequence only after the other observable sequence produces a value.

skip-while clj/s

(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 cljs

subject clj/s

(subject)

Subject that, once an Observer has subscribed, emits all subsequently observed items to the subscriber.

subject? clj/s

(subject? b)

Check if the provided value is Subject instance.

subscribe clj/s≠

clj

(subscribe ob nf)

(subscribe ob nf ef)

(subscribe ob nf ef cf)

(subscribe ob nf ef cf sf)

cljs

(subscribe ob nf)

(subscribe ob nf ef)

(subscribe ob nf ef cf)

Subscribes an observer to the observable sequence.

subscribe-on clj/s

(subscribe-on schd ob)

subscribe-with clj/s≠

clj

(subscribe-with ob subscriber)

Subscribes an observer or subscriber to the observable/flowable sequence.

cljs

(subscribe-with ob observer)

Subscribes an observer or subscriber to the observable sequence.

Subscriber cljs

take clj/s

(take n ob)

Bypasses a specified number of elements in an observable sequence and then returns the remaining elements.

take-until clj/s

(take-until other ob)

Returns the values from the source observable sequence until the other observable sequence or Promise produces a value.

take-while clj/s

(take-while f ob)

Returns elements from an observable sequence as long as a specified predicate returns true.

tap clj/s

(tap f ob)

(tap f g ob)

(tap f g e ob)

Invokes an action for each element in the observable sequence.

throttle clj/s

(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.

throw clj/s

(throw e)

timeout clj/s

(timeout ms ob)

(timeout ms other ob)

Returns the source observable sequence or the other observable sequence if dueTime elapses.

timer clj/s

(timer delay)

(timer delay period)

Returns an observable sequence that produces a value after ms has elapsed and then after each period.

to-atom clj/s

(to-atom ob)

(to-atom ob a)

(to-atom ob a f)

Materialize the observable sequence into an atom.

to-flowable clj

(to-flowable ob)

(to-flowable strategy ob)

Convert an observable into backpressure-aware Flowable instance.

to-serialized clj

(to-serialized s)

Converts an Subject into a Serialized Subject if not already Serialized.

transform clj/s

(transform xform ob)

Transform the observable sequence using transducers.

with-latest clj/s

(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.

zip clj/s

(zip & items)

Merges the specified observable sequences or Promises (cljs) into one observable sequence.