promesa.core — funcool/promesa 9.0.489

*loop-run-fn* clj/s

-> clj/s macro

(-> x & forms)

Like the clojure.core/->, but it will handle promises in values and make sure the next form gets the value realized instead of the promise.

Example fetching data in the browser with CLJS:

(p/-> (js/fetch #js {...}) ; returns a promise .-body)

The result of a thread is a promise that will resolve to the end of the thread chain.

->> clj/s macro

(->> x & forms)

Like the clojure.core/->>, but it will handle promises in values and make sure the next form gets the value realized instead of the promise.

Example fetching data in the browser with CLJS:

(p/->> (js/fetch #js {...}) ; returns a promise .-body read-string (mapv inc)

The result of a thread is a promise that will resolve to the end of the thread chain.

all clj/s

(all promises)

Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.

Example:

(-> (all [(promise :first-promise) (promise :second-promise)] (then (fn [[first-result second-result]])) (println (str first-result ", " second-result)

Will print out :first-promise, :second-promise.

If at least one of the promises is rejected, the resulting promise will be rejected.

any clj/s

(any promises)

(any promises default)

Given an array of promises, return a promise that is fulfilled when first one item in the array is fulfilled.

as-> clj/s macro

(as-> expr name & forms)

Like clojure.core/as->, but it will handle promises in values and make sure the next form gets the value realized instead of the promise.

bind clj/s

(bind p f)

(bind p f executor)

cancel! clj/s

(cancel! p)

Cancel the promise.

cancelled? clj/s

(cancelled? v)

Return true if v is a cancelled promise.

catch clj/s

(catch p f)

(catch p pred-or-type f)

Executes f when the promise p is rejected. Returns a promise resolved with the return value of f function handler.

catch' clj/s

(catch' p f)

(catch' p pred-or-type f)

Executes f when the promise p is rejected. Returns a promise resolved with the return value of f function handler.

chain clj/s

(chain p f)

(chain p f & fs)

Chain variable number of computations to be executed serially. Analogous to then that accepts variable number of functions.

chain' clj/s

(chain' p f)

(chain' p f & fs)

Chain variable number of computations to be executed serially. Unlike chain does not flatten the return value of each step (probably this is more performant than chain).

create clj/s

(create f)

(create f executor)

Create a promise instance from a factory function. If an executor is provided, the factory will be executed in the provided executor.

A factory function looks like (fn [resolve reject] (resolve 1)).

deferred clj/s

(deferred)

Creates an empty promise instance.

deferred? clj/s

(deferred? v)

Return true if v is a promise instance (alias to promise?).

delay clj/s

(delay t)

(delay t v)

(delay t v scheduler)

Given a timeout in miliseconds and optional value, returns a promise that will be fulfilled with provided value (or nil) after the time is reached.

do clj/s macro

(do & exprs)

An alias for do!

do! clj/s macro

(do! & exprs)

Execute potentially side effectful code and return a promise resolved to the last expression after awaiting the result of each expression.

done? clj

Returns true if promise p is already done.

doseq clj/s macro

(doseq [binding xs] & body)

Simplified version of doseq which takes one binding and a seq, and runs over it using promesa.core/run!

err clj/s

A short alias for error function.

error clj/s

(error f p)

(error f type p)

Same as catch but with parameters inverted.

extract clj

(extract p)

Returns the current promise value.

finally clj/s

(finally p f)

(finally p f executor)

Attach a potentially side-effectful handler to promise that will be executed independently if promise is resolved or rejected.

Returns the original promise and the return value of f function is ignored.

future clj/s macro

(future & body)

Analogous macro to clojure.core/future that returns promise instance instead of the Future. Exposed just for convenience and works as an alias to thread.

handle clj/s

(handle p f)

(handle p f executor)

Executes f when the promise p is resolved or is rejected. Returns a promise resolved with the return value of f function.

let clj/s macro

(let bindings & body)

A let alternative that always returns promise and waits for all the promises on the bindings.

loop clj/s macro

(loop bindings & body)

map clj/s

(map f p)

(map executor f p)

Chains a computation f (function) to be executed when the promise p is successfully resolved.

Unlike then, this does not perform automatic promise flattening. This is designed to be used with ->>.

mapcat clj/s

(mapcat f p)

(mapcat executor f p)

Chains a computation f (function) to be executed when the promise p is successfully resolved. f must return a promise that will be automatically unwrapped.

This is just a stricter version of then with reversed arguments in the same way as map.

This is designed to be used with ->>.

pending? clj

(pending? p)

Returns true if promise p is stil pending.

plet clj/s macro

(plet bindings & body)

A parallel let; executes all the bindings in parallel and when all bindings are resolved, executes the body.

promise clj/s

(promise v)

(promise v executor)

The coerce based promise constructor. Creates an appropriate promise instance depending on the provided value.

If an executor is provided, it will be used to resolve this promise.

promise? clj/s

(promise? v)

Return true if v is a promise instance.

promisify clj/s

(promisify callable)

Given a function that accepts a callback as the last argument, return a function that returns a promise. Callback is expected to take one parameter (result of a computation).

race clj/s

(race promises)

recur clj/s macro

(recur & args)

reject! clj/s

(reject! p e)

Reject a completable promise with an error.

rejected clj/s

(rejected v)

Return a rejected promise with provided reason.

rejected? clj

(rejected? p)

Returns true if promise p is already rejected.

resolve! clj/s

(resolve! o)

(resolve! o v)

Resolve a completable promise with a value.

resolved clj/s

(resolved v)

Return a resolved promise with provided value.

resolved? clj

(resolved? p)

Returns true if promise p is already fulfilled.

run! clj/s

(run! f coll)

(run! f coll executor)

A promise aware run! function.

then clj/s

(then p f)

(then p f executor)

Chains a computation f (function) to be executed when the promise p is successfully resolved.

The computation will be executed in the calling thread by default; you also can provide a custom executor.

If the function f returns a promise instance, it will be automatically unwrapped.

then' clj/s

(then' p f)

(then' p f executor)

Chains a computation f (function) to be executed when the promise p is successfully resolved.

The computation will be executed in the calling thread by default; you also can provide a custom executor.

Don't perform flatten on the result.

thenable? cljs

(thenable? v)

Returns true if v is a promise like object.

thread clj/s macro

(thread & body)

Analogous to clojure.core.async/thread that returns a promise instance instead of the Future.

thread-call clj/s

(thread-call f)

(thread-call executor f)

Analogous to clojure.core.async/thread that returns a promise instance instead of the Future. Useful for executing synchronous code in a separate thread (also works in cljs).

timeout clj/s

(timeout p t)

(timeout p t v)

(timeout p t v scheduler)

Returns a cancellable promise that will be fulfilled with this promise's fulfillment value or rejection reason. However, if this promise is not fulfilled or rejected within ms milliseconds, the returned promise is cancelled with a TimeoutError.

TimeoutException cljs

(TimeoutException message)

vthread clj/s macro

(vthread & body)

Analogous to clojure.core.async/thread that returns a promise instance instead of the Future. Useful for executing synchronous code in a separate thread (also works in cljs).

vthread-call clj/s

(vthread-call f)

A shortcut for (p/thread-call :vthread f).

with-redefs clj/s macro

(with-redefs bindings & body)

Like clojure.core/with-redefs, but it will handle promises in body and wait until they resolve or reject before restoring the bindings. Useful for mocking async APIs.

wrap clj/s

(wrap v)

A convenience alias for promise coercion function that only accepts a single argument.