zena:async

A child of the current scope, sharing its cancelled level.

A scope with no parent, wherever it is created: cancelling any other scope never reaches it, and only its holder can cancel it. This is the scope for work that must outlive its callers — a cache's shared fills, for example — where new CancelScope() would quietly parent to whichever scope happens to be current at construction.

Marks this scope and every descendant cancelled. Code between checkpoints is never interrupted: each frame bound to a marked scope raises at its next checkpoint. The root scope cannot be cancelled — code that started before any scope existed belongs to it, and cancelling everything is not a meaningful request.

Runs body with this scope as the current scope, so async frames created inside bind to it. Eager start does the inheritance: a frame's ramp runs synchronously here, reads the current scope once, and stores it — after creation the frame never consults it again.

Cancels every child (and work they spawned): marks the group's scope, so each child raises at its next checkpoint.

Starts body as a member of the group. The call begins here, synchronously, with the group's scope installed as current, so the new frame binds to it. The returned future is an ordinary future — anyone may await it — and the group watches it either way.

A future that completes once every member has settled — failing with the first member failure, if there was one. Joins while members are outstanding share one future. A join with nothing outstanding gets a fresh, already-settled future: settling and keeping the shared completer instead would break a group that spawns again after going idle, whose next drain would settle it a second time.

Runs every body as a member of a fresh group and gives the first settled outcome — value or failure — cancelling the rest. This is the loser-cancelling form of Future.race: race over already-started futures ignores its losers, because it does not own them, while this form starts the candidates itself and so may cancel the ones that lost. If cancellation instead arrives from outside — an ancestor scope cancels the group before any candidate settles — the returned future completes cancelled.

An empty array is refused: its future could never settle.

Whether this handle still holds its claim.

Starts body as owned work: the call runs under a new scope — a child of the current scope, so enclosing cancellation still reaches it — and the returned handle carries the one initial claim. Work that must not inherit the caller's cancellation runs the spawn under CancelScope.detached().

A second claim on the same work. Throws if this handle was already released — a released handle has nothing to share.

Gives this handle's claim up. Releasing the last claim cancels the work's scope one queue turn later. Idempotent, per handle.

Whether this future has settled. The one synchronous observation kept public: runtime infrastructure needs it (a Parker deciding whether a wake is already armed — zena:time/p3.zena), and unlike the settled STATE it does not let a result channel branch on an outcome it should only learn by subscribing.

A future of this future's value, transformed: once this settles with a value, the derived future settles with onValue(value) — and a callback result that is itself a future CHAINS, the derived future settling the way the inner one does (Awaited<R> is the type of that flattening, one level). A failure propagates untransformed unless onError is given, whose result then RECOVERS the chain; a callback that throws fails the derived future with what it threw, and is NOT caught by its own onError, which handles only this future's failure. Either callback runs from the microtask queue, never synchronously here.

Cancellation is not an error and has no callback: if this future completes cancelled, the derived future completes cancelled too, and neither callback runs. Reacting to a cancellation belongs to the scope that caused it, or to a finalizer (cancel, using) in the work being unwound — never to a result channel, where a handler could swallow the unwind (docs/design/cancellation.md).

An already-resolved future.

An already-failed future.

A future of every input's value, in input order regardless of the order they settle in — or of the first failure to arrive.

The failure is reported as soon as it happens, without waiting for the other inputs: once one has failed no combined value can exist, so waiting could only delay the answer, and would hang outright if another input never settles. Inputs that settle after that are ignored — they lost a race that was already decided, which is not an error.

With no inputs the result is an empty array. It still settles through the microtask queue like everything else (the always-async rule), so all never runs a continuation before its caller returns.

Futures are eager, so the inputs are already running when they get here: this waits for them, it does not start them.

A future settling as the first input to settle does — with its value, or with its failure. A failure wins a race exactly the way a value does; use it when the first answer is the answer, and note that the losers keep running (nothing here cancels them; that waits on cancellation).

Throws on an empty array rather than returning a future. A race with nothing in it can never settle, and a future that never settles surfaces much later as a deadlock report naming the awaiting code, so the mistake is refused where it was made.

A future of every input's outcome, value or failure alike, in input order. It settles only once every input has — there is no early exit to take, which is what lets this be ordinary async code: awaiting the inputs one at a time still finishes when the slowest input does, because the inputs are already running and a later input settles whether or not anything is awaiting it yet. (all and race answer BEFORE some inputs settle, so they need concurrent observation and stay subscription-shaped.)

Cancellation is not an outcome (no Err is minted for it, and Outcome has no third arm): catch cannot observe the cancellation channel, so awaiting a cancelled input unwinds this frame and the combined future completes cancelled — being downstream of cancelled work is inside the blast radius (docs/design/cancellation.md).

A future of the first input to settle with a value. Failures do not win: a failed input just leaves the race, and only when every input has failed does the result fail — with an AggregateError carrying each input's failure in input order.

The mirror image of all: all needs every value so one failure decides it, any needs one value so only total failure does. Throws on an empty array for race's reason — a future that can never settle surfaces much later, as a deadlock report far from the mistake.

Rejects the underlying future. Overridden by Completer<T>.

Settles with a value, reporting whether it won. False means someone else settled first — not an error for a caller racing on purpose.

Settles with a failure, reporting whether it won.