# Coroutine awaitables

The second part of the support is provided by header `<boost/outcome/coroutine_support.hpp>` (or `<boost/outcome/experimental/coroutine_support.hpp>` if you want Coroutine support for Experimental Outcome). This adds into namespace `BOOST_OUTCOME_V2_NAMESPACE::awaitables` (or `BOOST_OUTCOME_V2_NAMESPACE::experimental::awaitables`) these awaitable types suitable for returning from a Coroutinised function:

- `eager<T, Executor = void>`

  An eagerly evaluated Coroutine: invoking `co_await` upon a function returning one of these immediately begins the execution of the function now. If the function never suspends, the overhead is similar to calling an ordinary function.

- `lazy<T, Executor = void>`

  A lazily evaluated Coroutine (often named `task<T>` in most C++ Coroutine literature): invoking `co_await` upon a function returning one of these causes the function to be immediately suspended as soon as execution begins. Only resuming the execution of the coroutine proceeds execution.

- `generator<T, Executor = void>`

  A lazily evaluated generator of values: the coroutine is resumed to generate the next value, upon which it is suspended until the next iteration.

- `atomic_eager<T, Executor = void>`

  `eager<T>` does not employ thread synchronisation during resumption of dependent coroutines which is fine if you do not traverse kernel threads during a suspend-resume cycle. If you do however potentially traverse kernel threads during suspend-resume, you ought to use `atomic_eager<T>` instead – this uses atomics to synchronise the setting and checking of state to ensure correctness.

- `atomic_lazy<T, Executor = void>`

  Same for `lazy<T>` as `atomic_eager<T>` is for `eager<T>`.

Last revised: March 18, 2022 at 14:45:32 UTC