(-> 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.
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.
(->> 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.
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 promises)
Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled.
Example:
(-> (p/all [(promise :first-promise)
(promise :second-promise)])
(then (fn [[first-result second-result]])
(println (str first-result ", " second-result))))
Will print to out :first-promise, :second-promise
.
If at least one of the promises is rejected, the resulting promise will be rejected.
Given an array of promises, return a promise that is fulfilled when all the items in the array are fulfilled. Example: ``` (-> (p/all [(promise :first-promise) (promise :second-promise)]) (then (fn [[first-result second-result]]) (println (str first-result ", " second-result)))) ``` Will print to out `:first-promise, :second-promise`. If at least one of the promises is rejected, the resulting promise will be rejected.
(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.
Given an array of promises, return a promise that is fulfilled when first one item in the array is fulfilled.
(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.
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.
(await resource)
(await resource duration)
A exception safer variant of await!
. Returns nil
on timeout
exception, forwards interrupted exception and all other exceptions
are returned as value, so user is responsible for checking if the returned
value is exception or not.
A exception safer variant of `await!`. Returns `nil` on timeout exception, forwards interrupted exception and all other exceptions are returned as value, so user is responsible for checking if the returned value is exception or not.
(await! resource)
(await! resource duration)
Generic await operation. Block current thread until some operation
terminates. Returns nil
on timeout; does not catch any other
exception.
Default implementation for Thread, CompletableFuture and CountDownLatch.
The return value is implementation specific.
Generic await operation. Block current thread until some operation terminates. Returns `nil` on timeout; does not catch any other exception. Default implementation for Thread, CompletableFuture and CountDownLatch. The return value is implementation specific.
(bind p f)
(bind p f executor)
Chains a function f
to be executed with when the promise p
is
successfully resolved. Returns a promise that will mirror the
promise instance returned by calling f
with the value as single
argument; f
must return a promise instance.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
Chains a function `f` to be executed with when the promise `p` is successfully resolved. Returns a promise that will mirror the promise instance returned by calling `f` with the value as single argument; `f` **must** return a promise instance. The computation will be executed in the completion thread by default; you also can provide a custom executor.
(cancelled? v)
Return true if v
is a cancelled promise.
Return true if `v` is a cancelled promise.
(catch p f)
(catch p pred-or-type f)
Chains a function f
to be executed when the promise p
is
rejected. Returns a promise that will be resolved with the return
value of calling f
with exception as single argument; f
can
return a plain value or promise instance, an automatic unwrapping
will be performed.
The computation will be executed in the completion thread, look at
merr
if you want the ability to schedule the computation to other
thread.
Chains a function `f` to be executed when the promise `p` is rejected. Returns a promise that will be resolved with the return value of calling `f` with exception as single argument; `f` can return a plain value or promise instance, an automatic unwrapping will be performed. The computation will be executed in the completion thread, look at `merr` if you want the ability to schedule the computation to other thread.
(chain p f)
(chain p f & fs)
Chain variable number of functions to be executed serially using
then
.
Chain variable number of functions to be executed serially using `then`.
(chain' p f)
(chain' p f & fs)
Chain variable number of functions to be executed serially using
map
.
Chain variable number of functions to be executed serially using `map`.
(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))
.
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)
Creates an empty promise instance.
Creates an empty promise instance.
(deferred? v)
Return true if v
is a deferred instance.
Return true if `v` is a deferred instance.
(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.
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 & exprs)
Execute potentially side effectful code and return a promise resolved to the last expression after awaiting the result of each expression.
Execute potentially side effectful code and return a promise resolved to the last expression after awaiting the result of each expression.
(do! & exprs)
A convenience alias for do
macro.
A convenience alias for `do` macro.
(do* & exprs)
An exception unsafe do-like macro. Supposes that we are already wrapped in promise context so avoids defensive wrapping.
An exception unsafe do-like macro. Supposes that we are already wrapped in promise context so avoids defensive wrapping.
(done? p)
Returns true if promise p
is already done.
Returns true if promise `p` is already done.
(doseq [binding xs] & body)
Simplified version of doseq
which takes one binding and a seq, and
runs over it using promesa.core/run!
Simplified version of `doseq` which takes one binding and a seq, and runs over it using `promesa.core/run!`
(extract p)
(extract p default)
Returns the current promise value.
Returns the current promise value.
(finally p f)
(finally p f executor)
Like handle
but ignores the return value. Returns a promise that
will mirror the original one.
Like `handle` but ignores the return value. Returns a promise that will mirror the original one.
(fmap f p)
(fmap executor f p)
A convenience alias for map
.
A convenience alias for `map`.
(fnly f p)
(fnly executor f p)
Inverted arguments version of finally
; intended to be used with
->>
.
Inverted arguments version of `finally`; intended to be used with `->>`.
(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
.
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 p f)
(handle p f executor)
Chains a function f
to be executed when the promise p
is completed
(resolved or rejected) and returns a promise completed (resolving or
rejecting) with the return value of calling f
with both: value and
the exception; f
can return a new plain value or promise instance,
and automatic unwrapping will be performed.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
For performance sensitive code, look at hmap
and hcat
.
Chains a function `f` to be executed when the promise `p` is completed (resolved or rejected) and returns a promise completed (resolving or rejecting) with the return value of calling `f` with both: value and the exception; `f` can return a new plain value or promise instance, and automatic unwrapping will be performed. The computation will be executed in the completion thread by default; you also can provide a custom executor. For performance sensitive code, look at `hmap` and `hcat`.
(hcat f p)
(hcat executor f p)
Chains a function f
to be executed when the promise p
is completed
(resolved or rejected) and returns a promise that will mirror the
promise instance returned by calling f
with both: value and the
exception. The f
function must return a promise instance.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
Intended to be used with ->>
.
Chains a function `f` to be executed when the promise `p` is completed (resolved or rejected) and returns a promise that will mirror the promise instance returned by calling `f` with both: value and the exception. The `f` function must return a promise instance. The computation will be executed in the completion thread by default; you also can provide a custom executor. Intended to be used with `->>`.
(hmap f p)
(hmap executor f p)
Chains a function f
to be executed when the promise p
is completed
(resolved or rejected) and returns a promise completed (resolving or
rejecting) with the return value of calling f
with both: value and
the exception.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
Intended to be used with ->>
.
Chains a function `f` to be executed when the promise `p` is completed (resolved or rejected) and returns a promise completed (resolving or rejecting) with the return value of calling `f` with both: value and the exception. The computation will be executed in the completion thread by default; you also can provide a custom executor. Intended to be used with `->>`.
(let bindings & body)
A let
alternative that always returns promise and waits for all the
promises on the bindings.
A `let` alternative that always returns promise and waits for all the promises on the bindings.
(let* bindings & body)
An exception unsafe let-like macro. Supposes that we are already wrapped in promise context so avoids defensive wrapping.
An exception unsafe let-like macro. Supposes that we are already wrapped in promise context so avoids defensive wrapping.
(map f p)
(map executor f p)
Chains a function f
to be executed when the promise p
is
successfully resolved. Returns a promise that will be resolved with
the return value of calling f
with value as single argument.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
This function is intended to be used with ->>
.
Chains a function `f` to be executed when the promise `p` is successfully resolved. Returns a promise that will be resolved with the return value of calling `f` with value as single argument. The computation will be executed in the completion thread by default; you also can provide a custom executor. This function is intended to be used with `->>`.
(mapcat f p)
(mapcat executor f p)
Chains a function f
to be executed when the promise p
is
successfully resolved. Returns a promise that will mirror the
promise instance returned by calling f
with the value as single
argument; f
must return a promise instance.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
This funciton is intended to be used with ->>
.
Chains a function `f` to be executed when the promise `p` is successfully resolved. Returns a promise that will mirror the promise instance returned by calling `f` with the value as single argument; `f` **must** return a promise instance. The computation will be executed in the completion thread by default; you also can provide a custom executor. This funciton is intended to be used with `->>`.
(mcat f p)
(mcat executor f p)
A convenience alias for mapcat
.
A convenience alias for `mapcat`.
(merr f p)
(merr executor f p)
Chains a function f
to be executed when the promise p
is
rejected. Returns a promise that will mirror the promise returned by
calling f
with exception as single argument; f
must return a
promise instance or throw an exception.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
This is intended to be used with ->>
.
Chains a function `f` to be executed when the promise `p` is rejected. Returns a promise that will mirror the promise returned by calling `f` with exception as single argument; `f` **must** return a promise instance or throw an exception. The computation will be executed in the completion thread by default; you also can provide a custom executor. This is intended to be used with `->>`.
(pending? p)
Returns true if promise p
is stil pending.
Returns true if promise `p` is stil pending.
(plet bindings & body)
A parallel let; executes all the bindings in parallel and when all bindings are resolved, executes the body.
A parallel let; executes all the bindings in parallel and when all bindings are resolved, executes the body.
(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.
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? v)
Return true if v
is a promise instance.
Return true if `v` is a promise instance.
(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).
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).
(reject! p e)
Reject a completable promise with an error.
Reject a completable promise with an error.
(rejected v)
Return a rejected promise with provided reason.
Return a rejected promise with provided reason.
(rejected? p)
Returns true if promise p
is already rejected.
Returns true if promise `p` is already rejected.
(resolve! o)
(resolve! o v)
Resolve a completable promise with a value.
Resolve a completable promise with a value.
(resolved v)
Return a resolved promise with provided value.
Return a resolved promise with provided value.
(resolved? p)
Returns true if promise p
is already fulfilled.
Returns true if promise `p` is already fulfilled.
(run! f coll)
(run! f coll executor)
A promise aware run! function. Executed in terms of then
rules.
A promise aware run! function. Executed in terms of `then` rules.
(then p f)
(then p f executor)
Chains a function f
to be executed when the promise p
is
successfully resolved. Returns a promise that will be resolved with
the return value of calling f
with value as single argument; f
can return a plain value or promise instance, an automatic
unwrapping will be performed.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
Chains a function `f` to be executed when the promise `p` is successfully resolved. Returns a promise that will be resolved with the return value of calling `f` with value as single argument; `f` can return a plain value or promise instance, an automatic unwrapping will be performed. The computation will be executed in the completion thread by default; you also can provide a custom executor.
(then' p f)
(then' p f executor)
Chains a function f
to be executed when the promise p
is
successfully resolved. Returns a promise that will be resolved with
the return value of calling f
with value as single argument; f
should return a plain value, no automatic unwrapping will be
performed.
The computation will be executed in the completion thread by default; you also can provide a custom executor.
Chains a function `f` to be executed when the promise `p` is successfully resolved. Returns a promise that will be resolved with the return value of calling `f` with value as single argument; `f` should return a plain value, no automatic unwrapping will be performed. The computation will be executed in the completion thread by default; you also can provide a custom executor.
(thenable? v)
Returns true if v
is a promise like object.
Returns true if `v` is a promise like object.
(thread & body)
Analogous to clojure.core.async/thread
that returns a promise instance
instead of the Future
.
Analogous to `clojure.core.async/thread` that returns a promise instance instead of the `Future`.
(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).
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 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.
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.
(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).
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 f)
A shortcut for (p/thread-call :vthread f)
.
A shortcut for `(p/thread-call :vthread f)`.
(wait-all & promises)
Given a variable number of promises, returns a promise which resolves
to nil
when all provided promises complete (rejected or resolved).
EXPERIMENTAL
Given a variable number of promises, returns a promise which resolves to `nil` when all provided promises complete (rejected or resolved). **EXPERIMENTAL**
(wait-all! promises)
A blocking version of wait-all
.
A blocking version of `wait-all`.
(wait-all* promises)
Given an array of promises, return a promise that is fulfilled when all the items in the array are resolved (independently if successfully or exceptionally).
Example:
(->> (p/wait-all* [(promise :first-promise)
(promise :second-promise)])
(p/fmap (fn [_]
(println "done"))))
Rejected promises also counts as resolved.
Given an array of promises, return a promise that is fulfilled when all the items in the array are resolved (independently if successfully or exceptionally). Example: ``` (->> (p/wait-all* [(promise :first-promise) (promise :second-promise)]) (p/fmap (fn [_] (println "done")))) ``` Rejected promises also counts as resolved.
(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.
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 v)
A convenience alias for promise
coercion function that only accepts
a single argument.
A convenience alias for `promise` coercion function that only accepts a single argument.
cljdoc is a website building & hosting documentation for Clojure/Script libraries
× close