com.wsscode.async.async-clj — com.wsscode/async 1.0.11

<! clj macro

(<! & body)

Same as clojure.core.async/<!. Just a convenience place for it.

<!! clj macro

(<!! & body)

Same as clojure.core.async/<!!. Just a convenience place for it.

<!!maybe clj macro

(<!!maybe x)

Like <!maybe but will block the thread.

<!maybe clj macro

(<!maybe x)

Reads a channel if it is a channel, if it's not a channel, return x.

<? clj macro

(<? ch)

Reads a channel value and check if it is an error, in case it is, throw the error.

<?! clj macro

(<?! ch)

Reads a channel value and check if it is an error, in case it is, throw the error.

<?!maybe clj macro

(<?!maybe x)

A combination of <!maybe and <?.

<?maybe clj macro

(<?maybe x)

A combination of <!maybe and <?.

async-test clj macro

(async-test & body)

Ths is similar to the CLJS version for async test, but on the Clojure side the async helper doesn't exist, instead of using that we block on the wrapper go block. Example:

(deftest async-test
  (wa/async-test
    (is (= 42 (<! (some-async-op)))))

This will also add a timeout (default 2000ms), to change the timeout you can send a map with configuration after the test symbol, example:

(deftest async-test
  (wa/async-test
    {::wa/timeout 5000} ; 5000ms timeout
    (is (= 42 (<! (some-async-op)))))

catch-all clj macro

(catch-all & body)

Catches all Throwable exceptions and returns them as-is.

chan? clj

(chan? c)

Check if c is a core.async channel.

deftest-async clj macro

(deftest-async sym & body)

Define an async test, this helper uses the clojure.test async feature, the user body will be wrapped around a go block automatically and the async done will be called after the go block finishes it's execution. Example:

(wa/deftest-async async-test
  (is (= 42 (<! (some-async-op))))

This will also add a timeout (default 2000ms), to change the timeout you can send a map with configuration after the test symbol, example:

(wa/deftest-async async-test
  {::wa/timeout 5000} ; 5000ms timeout
  (is (= 42 (<! (some-async-op))))

If you want to use this with a different deftest constructor, use the async-test macro.

error? clj

(error? err)

Returns true if err is an error object.

go clj macro

(go & body)

Same as clojure.core.async/go. Just a convenience place for it.

go-catch clj macro

(go-catch & body)

Creates a go block that has a try/catch wrapping body, in case of errors the error flows up as data instead triggering the exception.

go-loop clj macro

(go-loop bindings & body)

Same as clojure.core.async/go-loop. Just a convenience place for it.

go-promise clj macro

(go-promise & body)

Creates a go block using a promise channel, so the output of the go block can be read any number of times once ready.

go-try-stream clj macro

(go-try-stream & args)

If you want to read from a stream and catch errors in the messages that come from it, this helper is for you.

The complication around adding try-catch on a go-loop is that we can't recur inside try/catch. This helper will create a structure around it that will catch errors and recur properly.

Usage:

(go-try-stream [value some-chan]
  (do-operation-here)
  (catch Throwable e
    (report-error e))

let-chan clj macro

(let-chan [name value] & body)

Handles a possible channel on value.

let-chan* clj macro

(let-chan* [name value] & body)

Like let-chan, but async errors will be returned instead of propagated

nil-safe-put! clj macro

(nil-safe-put! ch & body)

Puts result of body on the provided channel if non-nil, else it closes it. A workaround to allow communicating nils.

pulling-retry clj macro

(pulling-retry options & body)

Async pulling mechanism that will run body will ::done? is satisfied.

There two ways to call this helper: Shorthand version: pass the ::done? function and the body:

(wa/pulling-retry int? (do-something))

Or the full version to specify all details

(wa/pulling-retry {::wa/done? int?
                   ::wa/retry-ms 50
                   ::wa/timeout 3000}
  (do-something))

pulling-retry* clj

(pulling-retry* options f)

thread clj macro

(thread & body)

Same as clojure.core.async/thread. Just a convenience place for it.

thread-catch clj macro

(thread-catch & body)

Creates a thread that has a try/catch wrapping body, in case of errors the error flows up as data instead triggering the exception.

thread-promise clj macro

(thread-promise & body)

Creates a thread using a promise channel, so the output of the thread block can be read any number of times once ready.

throw-err clj

(throw-err x)

Throw error x if x is an error.

timeout-chan clj

(timeout-chan timeout-ms c)

Returns a channel that will respond will c, or an error after timeout-ms.