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

<! clj/s macro

(<! & body)

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

<!maybe clj/s macro

(<!maybe x)

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

<!p clj/s macro

(<!p promise)

Similar to core.async <!, but instead of taking a channel, <!p takes a Javascript Promise, converts to a channel and reads, this allows the use of regular JS promises inside go blocks using await like syntax.

Example:

(go ; start with go block
  (-> (js/fetch "some-url") <!p ; call fetch and await for response
      .text <!p ; await for text body reading
      js/console.log))

<? clj/s macro

(<? ch)

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

<?maybe clj/s macro

(<?maybe x)

Tries to await for a value, first if checks if x is a channel, if so will read on it; then it checks if it's a JS promise, if so will convert it to a channel and read from it. Otherwise returns x as is.

async-test clj/s macro

(async-test & body)

Creates an async block on the test, this helper uses the cljs.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:

(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)))))

chan? cljs

(chan? c)

Check if c is a core.async channel.

consumer-pair cljs

(consumer-pair resp)

Consume promise channel result pair.

deftest-async clj/s macro

(deftest-async sym & body)

Define an async test, this helper uses the cljs.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? cljs

(error? err)

Returns true if err is an error object.

go clj/s macro

(go & body)

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

go-catch clj/s 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/s macro

(go-loop bindings & body)

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

go-promise clj/s 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/s 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 :default e
    (report-error e))

let-chan clj/s macro

(let-chan [name value] & body)

Handles a possible channel on value.

let-chan* clj/s macro

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

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

promise->chan cljs

(promise->chan p)

Converts promise p in a promise-chan. The response of this channel should be consumed using consume-pair.

promise? cljs

(promise? x)

Return true if X is a js obj with the property .then available as a fn.

pulling-retry clj/s macro

(pulling-retry options & body)

Async pulling mechanism that will run body until ::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* cljs

(pulling-retry* options f)

throw-err cljs

(throw-err x)

Throw error x if x is an error.

timeout-chan cljs

(timeout-chan timeout-ms c)

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