halfling.task
attemptcljmacro
(attempt & body)Safely runs a body in a try block
and captures its outcome in a Result.
In case of a success, the result will look like:
{:status :success
:value <result of computation>}
In case of a failure, the result will look like: {:status :failure :value {:message <message of failure> :trace <possible stack trace>}
Safely runs a `body` in a `try` block
and captures its outcome in a `Result`.
In case of a success, the result will look like:
{:status :success
:value <result of computation>}
In case of a failure, the result will look like:
{:status :failure
:value {:message <message of failure>
:trace <possible stack trace>}broken?clj
(broken? task)Returns true if task has been realised and failed, false otherwise.
Note: Doesn't check if a task has been run.
An un-run task is still considered to be realised.
Returns `true` if `task` has been realised and failed, `false` otherwise. Note: Doesn't check if a task has been run. An un-run task is still considered to be realised.
const-futureclj
(const-future value)Wraps a value in a completed Future object.
Wraps a value in a completed `Future` object.
do-taskscljmacro
(do-tasks bindings & body)A let-like construct that allows working with
tasks as if they were successfully realised.
Binds single tasks to names in a let-like fashion and
considers the names as being the realised values of those tasks.
In addition, it also supports non-task expressions. These will
automatically be lifted to a task.
Example:
(do-tasks [a (task 1)
_ (println a)
b (task 2)]
(+ a b)
A `let`-like construct that allows working with
tasks as if they were successfully realised.
Binds single tasks to names in a `let`-like fashion and
considers the names as being the realised values of those tasks.
In addition, it also supports non-task expressions. These will
automatically be lifted to a `task`.
Example:
(do-tasks [a (task 1)
_ (println a)
b (task 2)]
(+ a b)done?clj
(done? task)Returns true if task has been realised, false otherwise.
Note: Doesn't check if the task has been run.
An un-run task is still considered to be realised.
For both checks, take a look at executed?.
Returns `true` if `task` has been realised, `false` otherwise. Note: Doesn't check if the task has been run. An un-run task is still considered to be realised. For both checks, take a look at `executed?`.
executed?clj
(executed? task)Returns true if task has been realised and run, false otherwise.
Returns `true` if `task` has been realised and run, `false` otherwise.
failureclj
(failure message)Given some string message, returns a realised failed task containing an error with the given message
Given some string `message`, returns a realised failed task containing an error with the given `message`
failure-tclj
(failure-t throwable)Given a proper error Throwable, returns a realised failed task containing it.
Given a proper error `Throwable`, returns a realised failed task containing it.
fulfilled?clj
(fulfilled? task)Returns true if task has been realised and was successful, false otherwise.
Note: Doesn't check if a task has been run.
An un-run task is still considered to be realised.
Returns `true` if `task` has been realised and was successful, `false` otherwise. Note: Doesn't check if a task has been run. An un-run task is still considered to be realised.
get!clj
(get! task)(get! task timeout else)Returns the value of the Result of task. Blocks task until it is realised.
If task is successful, returns its value.
If it is failed, returns the Throwable error object.
Note: Doesn't run the task!
Returns the value of the `Result` of `task`. Blocks `task` until it is realised. If `task` is successful, returns its value. If it is failed, returns the `Throwable` error object. Note: Doesn't run the task!
get-or-elseclj
(get-or-else task else)(get-or-else task timeout else)Returns the value of the Result of task if it was successful,
returns else otherwise. Block task until it is realised.
Note: Doesn't run the task!
Returns the value of the `Result` of `task` if it was successful, returns `else` otherwise. Block `task` until it is realised. Note: Doesn't run the task!
mapplyclj
(mapply f & tasks)Takes all the values of tasks and lazily applies a
function f on them if they were successful.
If one task fails, the total result will be a failure.
tasks will be run in parallel.
f is allowed to return both simple values and other tasks.
The arity of f is equal to the amount of tasks.
The following law applies:
(arity f) == (count tasks)
Takes all the values of `tasks` and lazily applies a function `f` on them if they were successful. If one task fails, the total result will be a failure. `tasks` will be run in parallel. `f` is allowed to return both simple values and other tasks. The arity of `f` is equal to the amount of `tasks`. The following law applies: (arity f) == (count tasks)
recoverclj
(recover task f)Recovers a failed task with function f.
NON-PARALLEL EXECUTION: f has a Throwable error object as an argument.
PARALLEL EXECUTION: f has a collection of Throwable error objects as an argument.
f may either return a simple value or another task.
Note: Tasks that are generally run in parallel are tasks composed together
using mapply, zip or sequenced.
Recovers a failed `task` with function `f`. NON-PARALLEL EXECUTION: `f` has a `Throwable` error object as an argument. PARALLEL EXECUTION: `f` has a collection of `Throwable` error objects as an argument. `f` may either return a simple value or another task. Note: Tasks that are generally run in parallel are tasks composed together using `mapply`, `zip` or `sequenced`.
runclj
(run task)Runs task synchronously.
Returns another task containing the result of that execution.
Note: Parallel tasks will be run in parallel,
but the current thread will be blocked until all tasks realise.
Runs `task` synchronously. Returns another task containing the result of that execution. Note: Parallel tasks will be run in parallel, but the current thread will be blocked until all tasks realise.
run-asyncclj
(run-async task)Runs task asynchronously.
Returns another task containing the result of that execution.
Note: Returns immediately. Parallel tasks will be run in parallel.
Runs `task` asynchronously. Returns another task containing the result of that execution. Note: Returns immediately. Parallel tasks will be run in parallel.
sequencedclj
(sequenced tasks)Takes a collection of tasks and lazily transforms it in a task containing
a collection of all the values of those tasks.
If one task fails, the total result will be a failure.
tasks will be run in parallel.
Takes a collection of tasks and lazily transforms it in a task containing a collection of all the values of those tasks. If one task fails, the total result will be a failure. `tasks` will be run in parallel.
successclj
(success value)Given some value, returns a realised successful task containing the given value
Given some `value`, returns a realised successful task containing the given `value`
taskcljmacro
(task & actions)Takes and number of expressions or actions and returns a task that will lazily evaluate them.
Takes and number of expressions or actions and returns a task that will lazily evaluate them.
thenclj
(then task f)Lazily applies a function f on the value of task only
in case it is successful. f is allowed to return both simple
values or other tasks.
The following law applies:
(then (task 1) #(inc %)) == (then (task 1) #(task (inc %))
Lazily applies a function `f` on the value of `task` only in case it is successful. `f` is allowed to return both simple values or other tasks. The following law applies: (then (task 1) #(inc %)) == (then (task 1) #(task (inc %))
then-docljmacro
(then-do task & body)A version of then where the result of task is ignored.
Lazily runs the body after the task ignoring the tasks return.
Mainly thought for sequential side-effects.
The following law applies:
(-> (task 1) (then-do (println 12))) == (do-tasks [_ (task 1) _ (println 12)])
A version of `then` where the result of `task` is ignored. Lazily runs the `body` after the `task` ignoring the `task`s return. Mainly thought for sequential side-effects. The following law applies: (-> (task 1) (then-do (println 12))) == (do-tasks [_ (task 1) _ (println 12)])
waitclj
(wait task)(wait task timeout else)Blocks thread until task has been realised.
Blocks thread until `task` has been realised.
zipclj
(zip & tasks)Takes the values of tasks and aggregates them to a vector if they were successful.
If one task fails, the total result will be a failure.
tasks will be run in parallel.
Takes the values of `tasks` and aggregates them to a vector if they were successful. If one task fails, the total result will be a failure. `tasks` will be run in parallel.
cljdoc is a website building & hosting documentation for Clojure/Script libraries
× close