seamless-async.core — com.github.s-doti/seamless-async 1.0.1

*async?* clj

async? is a system global boolean flag, which may be used as hint to various mechanisms, that are capable of both a/sync operations, for impacting their execution mode. This flag reflects the overall general expectation of the system, as to whether its execution should be a/sync. This flag is merely an optional approach to global coordination, and may be ignored. Default: false.

as-seq clj

(as-seq channel)

chan? clj

(chan? x)

Return true if x is a ManyToManyChannel.

go-go? clj macro

(go-go? async? & body)

Conditionally wraps code in a go block.

putc! clj

(putc! channel val)

Put & close. Asynchronously puts a val into channel, closing the channel when complete (nil values are not allowed). Returns true unless the channel is already closed.

s-> clj macro

(s-> x & forms)

Seamless -> threading, which applies seamless async glue as needed, in case any of the threaded expressions is asynchronous.

s->> clj macro

(s->> x & forms)

Seamless ->> threading, which applies seamless async glue as needed, in case any of the threaded expressions is asynchronous.

scallback clj

(scallback f
           &
           {:keys [callback err-callback]
            :or {callback identity err-callback identity}})

Takes a function f which expects callbacks, and optionally suitable callbacks implementations, and returns a non-blocking, streaming fn, that will be piping the result of the callbacks onto a channel. The returned fn has the same signature and logic as the original, but in place of a callback/err-callback fns, it takes simple flags :callback/:err-callback respectively, and returns a channel which will receive the result of the callbacks, then close. If no callbacks are provided, the identity fn will be used.

scond-> clj macro

(scond-> expr & clauses)

Seamless cond-> threading, which applies seamless async glue as needed, in case any of the threaded expressions is asynchronous.

scond->> clj macro

(scond->> expr & clauses)

Seamless cond->> threading, which applies seamless async glue as needed, in case any of the threaded expressions is asynchronous.

sderef clj

(sderef f)

(sderef f timeout-ms timeout-val)

Takes a function f which returns a derefable ref, and optionally timeout-ms and timeout-val, and returns a non-blocking, streaming fn, which also accomplishes the deref. The returned fn has the exact same signature and logic as the original, but its outcome will get deref'd by the cached threads pool (see: clojure.core.async/thread-macro-executor), and it returns a channel which will receive the result once available, then close.

seamless clj

(seamless f)

Takes a function f and returns a fn that can be seamlessly woven into an asynchronous flow. The returned fn has the exact same signature and logic as the original, but if any of its arguments originate in an async manner, they will be first asynchronously parked until their values are made available, and a channel will be returned immediately to the calling thread. The channel will receive the result (which may be a Throwable) once available, then close. However, if all values per input args are immediately available, the fn behaves as the original f. If an input arg turns out to be a Throwable, it is returned as the result under asynchronous conditions, else it will be thrown.

set-*async?* clj

(set-*async?* enabled?)

Sets the boolean state of the async? system global flag.

smap clj

(smap & args)

Seamless map, which behaves as map, but in case f is an asynchronous op, a channel will be returned, containing the outcome collection, once available.

smapcat clj

(smapcat & args)

Seamless mapcat, which behaves as mapcat, but in case f is an asynchronous op, a channel will be returned, containing the outcome collection, once available.

sputc! clj

(sputc! channel val)

Safe put & close. Asynchronously puts a val into channel, closing the channel when complete (closes the channel immediately if val is nil). Returns true unless the channel is already closed, or nil if val is nil.

sresolve clj

(sresolve coll)

Asynchronously replaces each channel encountered in coll with a single value taken from it. Returns a channel containing the outcome collection. If coll contains no channels, it is returned as is.

streamf clj

(streamf f)

Takes a blocking function f, eg. a db query, and returns a non-blocking, streaming fn. The returned fn has the exact same signature and logic as the original, but its logic will be carried out by the cached threads pool (see: clojure.core.async/thread-macro-executor), and it returns a channel which will receive the result of the execution when completed (throwables included), then close.