Glossary

To give up a suspended coroutine that its holder cannot resume, for example when the execution context or strand holding it is destroyed. The coroutine’s segment is unwound from its owner without any frame delivering a result. See abandon and Lifetime and Ownership.

The binding of a coroutine to a specific executor. A coroutine with affinity to executor ex has all its resumptions dispatched through ex. A task inherits its caller’s executor unless it is started with a run overload that takes an executor. See Executors and Execution Contexts.

A type-erased owning wrapper for executors. See any_executor and executor_ref.

To apply co_await to an awaitable to obtain its result. The coroutine suspends unless the result is already available.

A type that can be used with co_await. It either provides the awaiter functions await_ready(), await_suspend(), and await_resume() directly, or yields an awaiter through operator co_await.

The object whose await_ready(), await_suspend(), and await_resume() the compiler calls when a coroutine awaits.

A contiguous region of memory. See mutable_buffer (writable) and const_buffer (read-only).

A collection of buffers that can be iterated. Enables scatter/gather I/O with a single operation. See Buffer Sequences.

Asking an in-progress asynchronous operation to stop early through a stop token. Operations complete with an error code that compares equal to cond::canceled. See Stop Tokens and Cancellation.

The callable passed to run_async that receives the task’s result or exception when the task finishes.

An operation built from multiple primitive operations. For example, read repeatedly calls read_some() until the buffer is full.

The concept for awaitables whose await_suspend takes the execution environment as a second argument. Every awaitable a Capy coroutine awaits must satisfy it. See ContextAwaitable and The ContextAwaitable Protocol.

The code that runs after an asynchronous operation completes. In Capy it is always a suspended coroutine, whose handle is wrapped in a continuation that executors can queue without allocating.

A function that can suspend and resume execution. Uses the co_await, co_yield, or co_return keywords. See Introduction To C++20 Coroutines.

The memory holding a coroutine’s local variables, parameters, and promise across suspensions. Capy allocates it through the frame allocator.

A low-level handle to a suspended coroutine, represented by std::coroutine_handle<>.

Running a coroutine on an executor, inline when the caller is already on that executor, otherwise queued like a post.

The executor, stop token, and frame allocator that a coroutine chain passes to each awaitable it awaits. It also names the owner of the current segment. Represented by await_context.

A condition indicating no more data is available. Signaled by cond::eof.

A lightweight error indicator. See std::error_code.

A portable error classification. Enables comparing errors across categories. See cond.

A primitive that suspends any number of coroutines until it is set, then resumes all of them. See async_event.

An object that owns the resources work runs on, such as threads, and the services attached to them. It provides an executor. See execution_context and thread_pool.

An object that can dispatch or post coroutines for execution. Satisfies the Executor concept.

A type-erased, non-owning reference to an executor. It is the type tasks use to store the executor they resume on. See executor_ref.

The memory resource used to allocate coroutine frames. It travels with the environment and is installed in a thread-local slot while a coroutine runs. See Frame Allocators.

A test utility that injects errors at controlled points and reruns the test body, so every error path is exercised. See test::fuse.

An awaitable that satisfies the ContextAwaitable concept.

The code that performs I/O and reports completions, such as a wrapper over epoll, io_uring, or IOCP. Capy provides none. A library such as Corosio supplies one, and a type-erased stream hides which one is in use.

An awaitable that already holds its result and never suspends. Lets a function that sometimes completes synchronously return an awaitable without creating a coroutine. See immediate.

A coroutine that does not run until it is awaited or started. task is lazy.

A test double that satisfies the stream concepts and lets a test control the data and errors each read or write sees. See test::stream, test::read_stream, test::write_stream, and Mock Streams.

A type that can be moved but not copied. Tasks and type-erased streams are move-only.

A primitive that lets one coroutine at a time hold a lock, suspending the others instead of blocking their threads. See async_mutex.

The coroutine that started a segment. It stays suspended above the segment until the segment’s top task finishes, and it unwinds the segment if the segment is abandoned. See chain_owner.

Queuing a coroutine on an executor to run later, never inline.

A basic I/O operation like read_some() or write_some() that may transfer any amount of data.

The object inside a coroutine frame that controls the coroutine’s behavior, such as how it starts, finishes, and stores its result.

A task-like coroutine type that unwinds early when its stop token is triggered, instead of completing its body. See quitter.

The value a coroutine produces when it completes.

The result type for Capy operations: a std::tuple of an error code followed by optional payload values. Supports structured bindings. See results and The results Type.

Continuing execution of a suspended coroutine.

Awaiting a task from inside a coroutine with a different executor, stop token, or frame allocator. When the executor differs, the parent resumes on its own executor after the task finishes. See run.

Starting a task from outside a coroutine, such as from main. See run_async and Starting Coroutines.

Resuming a coroutine while saving and restoring the thread-local frame allocator, so coroutines do not overwrite each other’s allocator. Custom executor event loops must use safe_resume.

Reading into or writing from multiple non-contiguous buffers in a single operation.

The P2300 std::execution concept for objects that create senders. In Capy, the object that schedules work is an executor.

A run of coroutines started together. One segment is the task run_async starts and everything it awaits. A task run starts on another executor forms its own segment, as does each branch of when_all or when_any. See Lifetime and Ownership.

A P2300 std::execution object describing asynchronous work, connected to a receiver to run it. See Bridging a P2300 Sender.

A polymorphic component owned by an execution context. Provides shared functionality. See execution_context::use_service().

To begin executing a task. See run_async and run.

A mechanism for requesting cancellation. See std::stop_token.

An executor adaptor that ensures coroutines dispatched through it never run concurrently, even on a multi-threaded execution context. Eliminates data races without mutexes. See strand and Strand Serialization.

A sequence of bytes that can be read or written incrementally. See the ReadStream, WriteStream, and Stream concepts and Streams.

C++17 feature for unpacking tuple-like types: auto [a, b] = expr;

Pausing execution of a coroutine, yielding control to the caller or resumer.

Resuming another coroutine directly from await_suspend by returning its handle, so that the stack does not grow. A finished task returns to its parent this way.

The process-wide thread pool used when no explicit execution context is supplied. See get_system_context.

A lazy coroutine that produces a result. See task and The task Type.

An execution context that runs work on a fixed number of threads. See thread_pool.

The ability to use an object safely from multiple threads.

Describes a type that hides its concrete type behind a fixed interface, enabling runtime polymorphism without templates. See any_stream, any_read_stream, any_write_stream, and Type-Erased Wrappers.

A single-slot primitive that suspends one coroutine until a wakeup arrives from any thread. A wakeup that arrives before the coroutine waits is kept for its next wait. Used to connect external events, such as timers, to coroutines. See async_waker.

Awaiting several tasks concurrently and completing when all of them have finished. The first failure requests stop on the other tasks. See when_all and Concurrent Composition.

Awaiting several tasks concurrently and completing with the first one that succeeds. Stop is requested for the others, and all of them finish before it returns. A failing task does not stop the others. If every task fails, it completes with one of the failures. See when_any and Concurrent Composition.

Pending operations that keep an execution context running.

An object that keeps an execution context’s work count raised for its lifetime, so the execution context does not stop running. See work_guard.