Promise.all & gather

1// No std::when_all in the standard library (it is in the concurrency TS).
2// The hand-rolled version makes the semantics explicit — which is the point.
3std::vector<std::future<Part>> futures;
4for (auto& fetch : fetchers)
5  futures.push_back(std::async(std::launch::async, fetch));
6 
7std::vector<std::optional<Part>> parts(futures.size());
8std::vector<std::exception_ptr> errors(futures.size());
9 
10for (size_t i = 0; i < futures.size(); ++i) {
11  try { parts[i] = futures[i].get(); }        // blocks; rethrows this task's exception
12  catch (...) { errors[i] = std::current_exception(); }
13}
14// Note: every future is joined. Nothing is abandoned — but nothing is
15// cancelled either, so a fast failure does not save you any time.

There is no first-failure short-circuit unless you build one, and there is no cancellation to build it out of. The loop waits for every task regardless, which is allSettled semantics by default. Destroying a std::async future blocks in its destructor, so you cannot even walk away.

1// Rejects on the FIRST failure. The other four keep running.
2const [inv, price, reviews, recs, ship] = await Promise.all([
3  getInventory(id), getPrice(id), getReviews(id), getRecs(id), getShipping(id),
4])
5// If getPrice() rejects at 20ms, this throws at 20ms — and getReviews(),
6// getRecs() and getShipping() are still in flight, still holding sockets,
7// still going to settle into nobody.
8 
9// Report on all of them:
10const results = await Promise.allSettled([...])   // never rejects
11const failed = results.filter((r) => r.status === 'rejected')
12 
13// First success wins, ignore the rest:  await Promise.any([...])
14// First to SETTLE wins, success or failure: await Promise.race([...])

Promise.all is a fail-fast aggregator with no cancellation attached. To actually stop the abandoned work you must plumb an AbortController through every call and abort it in a finally — the language will not do it for you.

1// Make partial failure a value, so the compiler forces you to handle it.
2type Part<T> = { ok: true; value: T } | { ok: false; error: unknown }
3 
4async function all<T extends readonly unknown[]>(
5  tasks: { [K in keyof T]: Promise<T[K]> },
6  signal: AbortSignal,
7): Promise<{ [K in keyof T]: Part<T[K]> }> {
8  const settled = await Promise.allSettled(tasks as readonly Promise<unknown>[])
9  return settled.map((r) =>
10    r.status === 'fulfilled'
11      ? { ok: true as const, value: r.value }
12      : { ok: false as const, error: r.reason },
13  ) as { [K in keyof T]: Part<T[K]> }
14}
15 
16// Degrade explicitly, per part, at the render site:
17const [inv, price, reviews] = await all([getInventory(id, signal),
18  getPrice(id, signal), getReviews(id, signal)] as const, signal)
19if (!price.ok) return renderUnavailable()          // pricing is essential
20const reviewBlock = reviews.ok ? renderReviews(reviews.value) : null   // reviews are not

Promise<T> erases the failure type entirely, so Promise.all gives you a typed success tuple and an untyped throw. Modelling each part as a Result makes the essential-versus-optional decision explicit at the render site, which is where it belongs.

1# Default: first exception propagates; the OTHERS KEEP RUNNING.
2inv, price, reviews = await asyncio.gather(
3    get_inventory(id), get_price(id), get_reviews(id))
4 
5# Report on all of them — exceptions come back as VALUES, in order:
6results = await asyncio.gather(*calls, return_exceptions=True)
7failed = [r for r in results if isinstance(r, BaseException)]
8 
9# TaskGroup (3.11+): first failure CANCELS the siblings, then raises
10# an ExceptionGroup. This is structured concurrency — different semantics again.
11async with asyncio.TaskGroup() as tg:
12    t_inv = tg.create_task(get_inventory(id))
13    t_price = tg.create_task(get_price(id))
14# On exit: all tasks are done or cancelled. Nothing is left running.

Three behaviours in one standard library. gather() propagates the first exception and abandons its siblings; gather(return_exceptions=True) returns exceptions as ordinary values so nothing is lost; TaskGroup cancels the siblings and raises an ExceptionGroup. Only the third one leaves no orphans.