Constructs an instance of `java.util.concurrent.TimeUnit`.
If argument x is already an instance of `TimeUnit`, the function returns x.
Otherwise, x *must* be a keyword, in which case the following conversion
is performed:

:nanoseconds | :nanos | :ns   -> TimeUnit/NANOSECONDS
:microseconds | :us           -> TimeUnit/MICROSECONDS
:milliseconds | :millis | :ms -> TimeUnit/MILLISECONDS
:seconds | :sec               -> TimeUnit/SECONDS
:minutes | :mins              -> TimeUnit/MINUTES
:hours | :hrs                 -> TimeUnit/HOURS
:days                         -> TimeUnit/DAYS

Tests whether or not a strand is alive. 
A strand is alive if it has been started but has not yet died.

Calls f, which takes a callback of a single argument as its last parameter,
with arguments args, and blocks the current fiber until the callback is called,
then returns the value passed to the callback.

Creates a new channel.

Optional arguments:
capacity         - specifies how many messages the channel can contain (until they are consumed)
                   * A value of `0` designates a *transfer channel*, that blocks both `snd` and `rcv`
                     until a corresponding operation (`rcv` or `snd` respectively) is called.
                   * A value of `-1` creates an unbounded channel.

                   default: 0

overflow-policy  - specifies what `snd` does when the channel's capacity is exhausted.
                   May be one of:
                   * :throw    - throws an exception.
                   * :block    - blocks until a message is consumed and room is available
                   * :drop     - the message is silently dropped
                   * :displace - the old message waiting in the queue is discarded to make room for the new message.

                   default: :block

single-producer? - specifies if the channel should be single-producer.

                   default: false

single-consumer? - specifies if the channel should be single-consumer.

                   default: true

The default channel capacity is 0 and the default policy is :block

Closes a channel.
Messages already in the channel will be received, but all future attempts at `snd`
will silently discard the message. After all messages have been consumed, `rcv` will
return `nil`.

If an exception is passed as the second argument, then the same will happen, except after
all messages are consumed, the passed exception will be thrown by `rcv`, wrapped in a
`co.paralleluniverse.strands.channels.ProducerException`.

Tests whether a channel has been closed and contains no more messages that 
can be received.

Converts a time duration from one time unit to another.
x is the duration; `from-unit` and `to-unit` are the source
and target units repsectively, given as either a j.u.c.TimeUnit instance
or as a keyword, as specified by `->timeunit`.

Creates, but does not start a new fiber (a lightweight thread) running in a fork/join pool.

It is much preferable to use `spawn-fiber`.

Returns the currently running lightweight-thread or `nil` if none.

Returns the currently running fiber (if running in fiber)
or current thread (if not).

A global fiber scheduler. The scheduler uses all available processor cores.

Defines a suspendable function that can be used by a fiber or actor.
Used exactly like `defn`

Creates a double channel

Runs the given body in a newly created fiber and returns it.

Takes a spawned fiber yields a future object that will
invoke the function in another thread, and will cache the result and
return it on all subsequent calls to deref/@. If the computation has
not yet finished, calls to deref/@ will block, unless the variant
of deref with timeout is used. See also - realized?.

Creates a float channel

Creates an int channel

Awaits the termination of the given strand or strands, and returns
their result, if applicable.

If a single strand is given, its result is returned;
if a collection - then a collection of the respective results.

Note that for threads, the result is always `nil`, as threads don't return a value.

If a timeout is supplied and it elapses before the strand has terminated,
a j.u.c.TimeoutException is thrown.

s       - either a strand or a collection of strands.
timeout - how long to wait for the strands termination
unit    - the unit of the timeout duration. TimeUnit or keyword as in `->timeunit`

Defines a local suspendable function that can be used by a fiber or actor.
Used exactly like `letfn`

Creates a long channel

Returns a promise object that can be read with deref/@, and set,
once only, with deliver. Calls to deref/@ prior to delivery will
block, unless the variant of deref with timeout is used. All
subsequent derefs will return the same delivered value without
blocking. See also - realized?.

Unlike clojure.core/promise, this promise object can be used inside Pulsar fibers.

Receives a message from a channel.
This function will block until a message is available or until the timeout,
if specified, expires.
If a timeout is given, and it expires, rcv returns nil.
Otherwise, the message is returned.

Receives a double value from a double-channel.

See: `rcv`

Receives a float value from a float-channel.

See: `rcv`

Receives an int value from an int-channel.

See: `rcv`

Receives at most n values from the given channel and conjoins them
into the to collection

Receives a long value from a long-channel.

See: `rcv`

Performs up to one of several given channel operations.
sel takes a collection containing *channel operation descriptors*. A descriptor is 
either a channel or a pair (vector) of a channel and a message. 
Each channel in the sequence represents a `rcv` attempt, and each channel-message pair 
represents a `snd` attempt. 
The `sel` function performs at most one operation on the sequence, a `rcv` or a `snd`, 
which is determined by the first operation that can succeed. If no operation can be 
carried out immediately, `sel` will block until an operation can be performed, or the
optionally specified timeout expires.
If two or more operations are available at the same time, one of them will be chosen
at random, unless the `:priority` option is set to `true`.

Options:
:priority bool -  If set to `true`, then whenever two or more operations are available
                  the first among them, in the order they are listed in the `ports` collection,
                  will be the one executed.
:timeout millis - If timeout is set and expires before any of the operations are available,
                  the function will return `nil`

Returns:
If an operation succeeds, returns a vector `[m ch]` with `m` being the message received if the
operation is a `rcv`, or `nil` if it's a `snd`, and `ch` is the channel on which the succesful
opration was performed.
If a timeout is set and expires before any of the operations are available, returns `nil`.

Performs a very similar operation to `sel`, but allows you to specify an action to perform depending 
on which operation has succeeded.
Takes an even number of expressions, ordered as (ops1, action1, ops2, action2 ...) with the ops being 
a channel operation descriptior (remember: a descriptor is either a channel for an `rcv` operation, 
or a vector of a channel and a message specifying a `snd` operation) or a collection of descriptors, 
and the actions are Clojure expressions. 
Like `sel`, `select` performs at most one operation, in which case it will run the operation's 
respective action and return its result.

An action expression can bind values to the operations results. 
The action expression may begin with a vector of one or two symbols. In that case, the first symbol 
will be bound to the message returned from the successful receive in the respective ops clause 
(or `nil` if the successful operation is a `snd`), and the second symbol, if present, will be bound 
to the successful operation's channel.

Like `sel`, `select` blocks until an operation succeeds, or, if a `:timeout` option is specified, 
until the timeout (in milliseconds) elapses. If a timeout is specfied and elapses, `select` will run 
the action in an optional `:else` clause and return its result, or, if an `:else` clause is not present, 
`select` will return `nil`.

Example:

(select :timeout 100 
       c1 ([v] (println "received" v))
       [[c2 m2] [c3 m3]] ([v c] (println "sent to" c))
       :else "timeout!")

In the example, if a message is received from channel `c1`, then it will be printed. 
If a message is sent to either `c2` or `c3`, then the identity of the channel will be printed, 
and if the 100 ms timeout elapses then "timeout!" will be printed.

Turns a sequence into a receive port that receives all values in the sequence

Creates a suspendable function that can be used by a fiber or actor.
Used exactly like `fn`

Returns a channel that receives a single, given value
and then closes

Suspends the current strand.

Sends a message to a channel.
If the channel's overflow policy is `:block` than this function will block
if the channels' capacity is exceeded.

Sends a double value to a double-channel.  

See: `snd`

Sends a float value to a float-channel.  

See: `snd`

Sends an int value to an int-channel.

See: `snd`

Sends a long value to a long-channel.  

See: `snd`

Sends a sequence of messages to a channel

Creates and starts a new fiber.

f - the function to run in the fiber.
args - (optional) arguments for the function

Options:
:name str     - the fiber's name
:stack-size n - the fiber's initial stack size
:scheduler    - the fiber schdeuler in which the fiber will run

Creates and starts a new thread.

f - the function to run in the thread.
args - (optional) arguments to pass to the function

Options:
:name str     - the thread's name

Creates a suspendable implementation of a protocol or interface.
sreify is to reify what sfn is to fn.

Starts a fiber created with `create-fiber`.

A suspendable version of trampoline. Should be used to implement
finite-state-machine actors.

trampoline can be used to convert algorithms requiring mutual
recursion without stack consumption. Calls f with supplied args, if
any. If f returns a fn, calls that fn with no arguments, and
continues to repeat, until the return value is not a fn, then
returns that non-fn value. Note that if you want to return a fn as a
final value, you must wrap it in some data structure and unpack it
after trampoline returns.

Subscribes a channel to a topic.
The subscribed channel will receive all messages sent to the topic.

Makes a function suspendable.

Returns true of a function has been instrumented as suspendable; false otherwise.

Creates a rcv-port (read-only channel) that returns messages from a *ticker channel*.
A ticker channel is a bounded channel with an overflow policy of :displace.

Different ticker consumers are independent (a message received from one is not removed from others),
and guarantee monotonicty (messages are received in order), but if messages are sent to the
ticker channel faster than they are consumed then messages can be lost.

Creates a new topic.
A topic is a send-port (a write-only channel) that forwards every message sent to it
to a group of subscribed channels.
Use `subscribe!` and `unsubscribe!` to subscribe and unsubscribe a channel to or from
the topic.

Attempts to immediately (without blocking) receive a message from a channel.
Returns the message if one is immediately available; `nil` otherwise.
This function never blocks.

Tries to immediately send a message to a channel.
If the channel's capacity is exceeded, this function fails and returns `false`.
Returns `true` if the operation succeeded; `false` otherwise.
This function never blocks.

Tries to immediately send a double value to a double-channel.
Returns `true` if successful, `false` otherwise.  

See: `try-snd`

Tries to immediately send a float value to a float-channel.
Returns `true` if successful, `false` otherwise.  

See: `try-snd`

Tries to immediately send an int value to an int-channel.
Returns `true` if successful, `false` otherwise.

See: `try-snd`

Tries to immediately send a long value to a long-channel.
Returns `true` if successful, `false` otherwise.  

See: `try-snd`

Unsubscribes a channel from a topic.
The channel will stop receiving messages sent to the topic.