clojure.core.async
(source)Facilities for async programming and communication.
go blocks are dispatched over an internal thread pool, which
defaults to 8 threads. The size of this pool can be modified using
the Java system property `clojure.core.async.pool-size`.
Set Java system property `clojure.core.async.go-checking` to true
to validate go blocks do not invoke core.async blocking operations.
Property is read once, at namespace load time. Recommended for use
primarily during development. Invalid blocking calls will throw in
go block threads - use Thread.setDefaultUncaughtExceptionHandler()
to catch and handle.
For more info about this library see:
https://clojuredocs.org/clojure.core.async| Public Variable | Short Description |
|---|---|
| <! (clj) | takes a val from port. |
| <!! (clj) | takes a val from port. |
| >! (clj) | puts a val into port. |
| >!! (clj) | puts a val into port. |
| Mix (clj) | |
| Mult (clj) | |
| Mux (clj) | |
| Pub (clj) | |
| admix (clj) | Adds ch as an input to the mix. |
| admix* (clj) | |
| alt! (clj) | Makes a single choice between one of several channel operations, as if by alts!, returning the value of the result expr corresponding to the operation completed. |
| alt!! (clj) | Like alt!, except as if by alts!!, will block until completed, and not intended for use in (go ...) blocks. |
| alts! (clj) | Completes at most one of several channel operations. |
| alts!! (clj) | Like alts!, except takes will be made as if by <!!, and puts will be made as if by >!!, will block until completed. |
| buffer (clj) | Returns a fixed buffer of size n. |
| chan (clj) | Creates a channel with an optional buffer, an optional transducer (like (map f), (filter p) etc or a composition thereof), and an optional exception-handler. |
| close! (clj) | Closes a channel. |
| defblockingop (clj) | |
| do-alt (clj) | |
| do-alts (clj) | returns derefable [val port] if immediate, nil if enqueued. |
| dropping-buffer (clj) | Returns a buffer of size n. |
| fn-handler (clj) | |
| go (clj) | Asynchronously executes the body, returning immediately to the calling thread. |
| go-loop (clj) | Like (go (loop ...)). |
| into (clj) | Returns a channel containing the single (collection) result of the items taken from the channel conjoined to the supplied collection. |
| ioc-alts! (clj) | |
| map (clj) | Takes a function and a collection of source channels, and returns a channel which contains the values produced by applying f to the set of first items taken from each source channel, followed by applying f to the set of second items from each channel, until any one of the channels is closed, at which point the output channel will be closed. |
| merge (clj) | Takes a collection of source channels and returns a channel which contains all values taken from them. |
| mix (clj) | Creates and returns a mix of one or more input channels which will be put on the supplied out channel. |
| mult (clj) | Creates and returns a mult(iple) of the supplied channel. |
| muxch* (clj) | |
| offer! (clj) | Puts a val into port if it's possible to do so immediately. |
| onto-chan (clj) | Deprecated - use onto-chan! or onto-chan!!. |
| onto-chan! (clj) | Puts the contents of coll into the supplied channel. |
| onto-chan!! (clj) | Like onto-chan! for use when accessing coll might block, e.g. |
| pipe (clj) | Takes elements from the from channel and supplies them to the to channel. |
| pipeline (clj) | Takes elements from the from channel and supplies them to the to channel, subject to the transducer xf, with parallelism n. |
| pipeline-async (clj) | Takes elements from the from channel and supplies them to the to channel, subject to the async function af, with parallelism n. |
| pipeline-blocking (clj) | Like pipeline, for blocking operations. |
| poll! (clj) | Takes a val from port if it's possible to do so immediately. |
| promise-chan (clj) | Creates a promise channel with an optional transducer, and an optional exception-handler. |
| pub (clj) | Creates and returns a pub(lication) of the supplied channel, partitioned into topics by the topic-fn. |
| put! (clj) | Asynchronously puts a val into port, calling fn1 (if supplied) when complete, passing false iff port is already closed. |
| reduce (clj) | f should be a function of 2 arguments. |
| sliding-buffer (clj) | Returns a buffer of size n. |
| solo-mode (clj) | Sets the solo mode of the mix. |
| solo-mode* (clj) | |
| split (clj) | Takes a predicate and a source channel and returns a vector of two channels, the first of which will contain the values for which the predicate returned true, the second those for which it returned false. |
| sub (clj) | Subscribes a channel to a topic of a pub. |
| sub* (clj) | |
| take (clj) | Returns a channel that will return, at most, n items from ch. |
| take! (clj) | Asynchronously takes a val from port, passing to fn1. |
| tap (clj) | Copies the mult source onto the supplied channel. |
| tap* (clj) | |
| thread (clj) | Executes the body in another thread, returning immediately to the calling thread. |
| thread-call (clj) | Executes f in another thread, returning immediately to the calling thread. |
| timeout (clj) | Returns a channel that will close after msecs. |
| to-chan (clj) | Deprecated - use to-chan! or to-chan!!. |
| to-chan! (clj) | Creates and returns a channel which contains the contents of coll, closing when exhausted. |
| to-chan!! (clj) | Like to-chan! for use when accessing coll might block, e.g. |
| toggle (clj) | Atomically sets the state(s) of one or more channels in a mix. |
| toggle* (clj) | |
| transduce (clj) | async/reduces a channel with a transformation (xform f). |
| unblocking-buffer? (clj) | Returns true if a channel created with buff will never block. |
| unmix (clj) | Removes ch as an input to the mix. |
| unmix* (clj) | |
| unmix-all (clj) | removes all inputs from the mix. |
| unmix-all* (clj) | |
| unsub (clj) | Unsubscribes a channel from a topic of a pub. |
| unsub* (clj) | |
| unsub-all (clj) | Unsubscribes all channels from a pub, or a topic of a pub. |
| unsub-all* (clj) | |
| untap (clj) | Disconnects a target channel from a mult. |
| untap* (clj) | |
| untap-all (clj) | Disconnects all target channels from a mult. |
| untap-all* (clj) |