Converts, if possible, the object to a Manifold sink, or default-val if it cannot. If no default value is given, an IllegalArgumentException is thrown.

Converts, if possible, the object to a Manifold source, or default-val if it cannot. If no default value is given, an IllegalArgumentException is thrown.

Batches messages, either into groups of fixed size, or according to upper bounds on size and latency, in milliseconds. By default, each message is of size 1, but a custom metric function that returns the size of each message may be defined.

Takes a stream, and returns a stream which is a buffered view of that stream. The buffer size may either be measured in messages, or if a metric is defined, by the sum of metric mapped over all messages currently buffered.

A stream which will buffer at most limit data, where the size of each message is defined by (metric message).

Closes a source or sink, so that it can’t emit or accept any more messages.

Returns true if the event sink is closed.

Takes a stream of streams, and flattens it into a single stream.

Connects a source to a sink, propagating all messages from the former into the latter.

Optionally takes a map of parameters:

Feeds all messages from src into callback, with the understanding that they will eventually be propagated into dst in some form. The return value of callback should be a deferred yielding either true or false. When false, the downstream sink is assumed to be closed, and the connection is severed.

Returns a deferred which yields true when src is exhausted or callback yields false.

Feeds all messages from source into callback.

Messages will be processed as quickly as the callback can be executed. Returns a deferred which yields true when source is exhausted.

Feeds all messages from source into callback, which must return a deferred yielding true or false. If the returned value yields false, the consumption will be cancelled.

Messages will be processed only as quickly as the deferred values are realized. Returns a deferred which yields true when source is exhausted or callback yields false.

Returns a description of the stream.

Returns all sinks downstream of the given source as a sequence of 2-tuples, with the first element containing the connection’s description, and the second element containing the sink.

Takes all messages from src and puts them into dst, and returns a deferred that yields true once src is drained or dst is closed. If src is closed or drained, dst will not be closed.

Returns true if the event source is drained.

Equivalent to Clojure’s filter, but for streams instead of sequences.

Equivalent to Clojure’s partition-by, but returns a stream of streams. This means that if a sub-stream is not completely consumed, the next sub-stream will never be emitted.

Use with caution. If you’re not totally sure you want a stream of streams, use (transform (partition-by f)) instead.

Equivalent to Clojure’s map, but for streams instead of sequences.

Equivalent to Clojure’s mapcat, but for streams instead of sequences.

Registers a no-arg callback which is invoked when the sink is closed.

Registers a no-arg callback which is invoked when the source is drained.

Returns an identical stream whose deferred callbacks will be executed on executor.

Creates a stream which emits the result of invoking (f) every period milliseconds.

Puts a value into a sink, returning a deferred that yields true if it succeeds, and false if it fails. Guaranteed to be non-blocking.

Puts all values into the sink, returning a deferred that yields true if all puts are successful, or false otherwise. If the sink provides backpressure, will pause. Guaranteed to be non-blocking.

Takes a stream of potentially deferred values, and returns a stream of realized values.

Equivalent to Clojure’s reduce, but returns a deferred representing the return value.

The deferred will be realized once the stream is closed or if the accumulator functions returns a reduced value.

Equivalent to Clojure’s reductions, but for streams instead of sequences.

Returns a view of the stream which is only a sink.

Returns true if the object is a Manifold sink.

Returns a view of the stream which is only a source.

Returns true if the object is a Manifold source.

Splices together two halves of a stream, such that all messages enqueued via put! go into sink, and all messages dequeued via take! come from source.

Returns a Manifold stream with a configurable buffer-size. If a capacity is specified, put! will yield true when the message is in the buffer. Otherwise it will only yield true once it has been consumed.

xform is an optional transducer, which will transform all messages that are enqueued via put! before they are dequeued via take!.

executor, if defined, specifies which java.util.concurrent.Executor will be used to handle the deferreds returned by put! and take!.

An alternate way to build a stream, via a map of parameters.

Transforms a stream into a lazy sequence. If a timeout-interval is defined, the sequence will terminate if timeout-interval milliseconds elapses without a new event.

Returns true if the object is a Manifold stream.

Returns true if the underlying abstraction behaves synchronously, using thread blocking to provide backpressure.

Takes a value from a stream, returning a deferred that yields the value when it is available, or nil if the take fails. Guaranteed to be non-blocking.

A special default-val may be specified, if it is important to differentiate between actual nil values and failures.

Limits the max-rate that messages are emitted, per second.

The max-backlog dictates how much “memory” the throttling mechanism has, or how many messages it will emit immediately after a long interval without any messages. By default, this is set to one second’s worth.

Takes a transducer xform and returns a source which applies it to source s. A buffer-size may optionally be defined for the output source.

Puts a value into a stream if the put can successfully be completed in timeout milliseconds. Returns a promise that yields true if it succeeds, and false if it fails or times out. Guaranteed to be non-blocking.

A special timeout-val may be specified, if it is important to differentiate between failure due to timeout and other failures.

Takes a value from a stream, returning a deferred that yields the value if it is available within timeout milliseconds, or nil if it fails or times out. Guaranteed to be non-blocking.

Special timeout-val and default-val values may be specified, if it is important to differentiate between actual nil values and failures.

Returns a weak reference that can be used to construct topologies of streams.

Takes n-many streams, and returns a single stream which will emit n-tuples representing a message from each stream.