Cooperative Async Task Group · Analysis

01 · Frame the problem

Understand the central challenge

Design a single-event-loop task group with a concurrency bound and fail-fast cancellation requests. Child factories receive a cooperative abort signal; joining must wait for every started child to settle.

Structured concurrency means the parent retains ownership of every started child until it settles. Analyse failure, queued work, cancellation cooperation and join closure rather than equating cancellation request with task termination.

02 · Find the design pressure

Start simple, then identify the gap

Begin with bounded submission and an active-child set. Returning on first error leaves started tasks orphaned. Stop admission, skip unstarted work and await all started outcomes, recording children that do not immediately honor cancellation.

Maintain a bounded submission queue and active child set under one event loop. A first failure requests cancellation and skips unstarted children, while join closes submissions and waits for all started children to settle before returning collected outcomes. Validate concurrency and queue bounds. submit accepts a task factory only while OPEN and returns an outcome handle; overload and closed submission are explicit errors. Drain up to the concurrency limit, wrapping synchronous factory throws and immediately observing each returned promise. Store success or failure outcomes and remove the child from the active set in a finalizer. On first failure or explicit cancellation, set the cancellation flag before invoking abort callbacks, skip queued factories and request cooperative cancellation of active tasks. Capture later failures as additional outcomes. join is idempotent and changes OPEN to CLOSING. Continue normal queued work if not cancelled, and settle the shared join promise only when no active or queued work remains. A child ignoring cancellation can keep it pending; diagnostics must not misreport termination.

03 · Define success

Requirements to preserve

Bound running tasks and queued factories.
Close submission before joining.
Stop launching queued work after cancellation or child failure.
Collect failures and do not claim forced cancellation of arbitrary promises.

04 · Identify the correctness boundary

Invariants, representation and mutation boundaries

Track queued and started children separately. On first failure, request cooperative cancellation and skip unstarted work, but join still waits for started children to settle. Cancellation cannot forcibly stop arbitrary child code, so the group must not report completion while a started task is still running.

05 · Make it concrete

Reason through a worked example

With concurrency 2, A and B start while C waits. A fails, C becomes skipped and B receives cancellation. If B ignores cancellation and finishes later, join waits for it and records its outcome. No late child continuation can mutate an already reported group result.