A work-a-like for clojure.core.async/alts!. Given a collection of
events returns a new event that when sync'ed chooses one event and
returns [event-value event].

Event that has always already occured. Synchronization always succeeds
immediately. Value of the event is true.

Given a function f, applies f to a function g and an event e. e becomes
occurs when g is invoked and has the value `true`. returns the result of invoking f.

Create a buffered full duplex channel. The buffer allows for senders
to add to the channel without waiting for a receiver until the
buffer's capacity is reached. Buffered channels optional can have a
transducer (xform) which transforms values that flow through the
channel. If a transducer is specified, optional an exception halder
can be specified to handle any exceptions that may arise.

Returns full duplex channel, both a SendChannel and a ReceiveChannel

Takes a collection of events, and non-deterministically selects one on
synchronization by defaults.

Close a channel.

Returns an event that is immediatly synchronizable with the value value

Returns an event that is immediatly synchronizable with the error value

A dropping buffer for buffered-channel. Always accepts inputs, but
inputs are silently dropped if the buffer is full.

A fixed size buffer for buffered-channel. Accepts inputs until full.

Given a SendChannel and a ReceiveChannel return a single channel that
is both send and receivable.

Takes a function of no arguments f, returns an event E, before E is
synchronized on, f will be invoked, and E replaced with the event
returned by f.

Middleware smart constructor for building events. Middleware wraps an
event, passing protocol calls down with the opportunity to intercept
and make changes. The middleware smart constructor can collapse
multiple middlewares into a single middleware via function
composition.

Like guard, but f is passed an event G. G will occur if on
synchronization, the chosen event is not the one returned by f.

Takes a collection of events, and attempts to select
event to synchronize on in order.

A pubsub allows messages to be sent to topics. input is a channel of
messages, topic-fn is message -> topic. All listeners to a topic are
sent messages in parallel. The pubsub will not move on to the next
message until all listeners have recieved a given message.

Creates an event where synchronization completes after receivng a value
via the given channel or the channel is closed. Returns the received
value or nil.

Given a full duplex channel return a channel that is only a
ReceiveChannel

Creates an event where synchronization completes after the given value
has been sent via the given channel, or after the given channel
closes. Returns true or false

Given a full duplex channel return a channel that is only a
SendChannel

A sliding buffer for buffered-channel. Always accepts inputs, but
drops the oldest item if the buffer is full.

Given a pubsub add a channel as a listener to a given topic. Returns
an event that must be synchronized on. After that event occurs the
  listener has been added to the pubsub. If close? is true then the
  listener channel will be closed if the input to the pubsub is
  closed.

Run a callback after the given event occurs. Returns a
CompletableFuture (or whatever the platform supplied promise like
type is) that will be completed after the event occurs.

Stop and wait for the given event to occur

Given a delay in milliseconds, returns an event that doesn't
synchronize until after that delay has elapsed. Value of the event
is true.

Remove a channel as a listener for the given topic from a
pubsub. Returns an event that must be synchronized on.

Return an event that syncs when the given watchable clojure reference
type (refs,atoms,agents) has the given value. Event has the value
true.

Return an event that occurs when the given watchable clojure
reference's value is such that (test value) is truthy. Event has the
value true.

Wraps the post synchronization action f around the event evt

Wrap an error handler around an event. Handlers errors coming out of
the event itself, or any errors arising from other wrappings of the
event.