gleam/otp/task

A task is a kind of process that performs a single task and then shuts down. Commonly tasks are used to convert sequential code into concurrent code by performing computation in another process.

let t = task.async(fn() { do_some_work() })
res = do_some_other_work()
res + task.await(t, 100)

Tasks spawned with async can be awaited on by their caller process (and only their caller) as shown in the example above. They are implemented by spawning a process that sends a message to the caller once the given computation is performed.

There are two important things to consider when using async:

1. If you are using async tasks, you must await a reply as they are always sent.

2. async tasks link the caller and the spawned process. This means that, if the caller crashes, the task will crash too and vice-versa. This is on purpose: if the process meant to receive the result no longer exists, there is no purpose in completing the computation.

This module is inspired by Elixir's Task module.

pub type AwaitError {
  Timeout
  Exit(reason: Dynamic)
}

pub opaque type Task(value)

pub fn async(work: fn() -> a) -> Task(a)

pub fn await(task: Task(a), timeout: Int) -> a

pub fn try_await(
  task: Task(a),
  timeout: Int,
) -> Result(a, AwaitError)