Combiner des promesses, ou le type dit comment ça échoue Combining promises, or the type says how it fails

Promise.all lance en parallèle — et rend un tuple typé, position par position.Promise.all runs in parallel — and returns a typed tuple, position by position.

On a souvent plusieurs opérations asynchrones indépendantes. Les enchaîner par des await successifs les sérialise sans raison : la seconde attend la première. Les combinateurs lancent tout de front — et leurs types réservent des subtilités qu'on néglige. Promise.all est le plus utile : il attend que tout résolve, et rend un tuple où chaque position garde son type exact. Pas un tableau de l'union des types : un tuple [User, Post[]], déstructurable proprement.You often have several independent async operations. Chaining them with successive awaits serializes them for no reason: the second waits for the first. Combinators launch everything at once — and their types hold subtleties that get overlooked. Promise.all is the most useful: it waits for all to resolve, and returns a tuple where each position keeps its exact type. Not an array of the union of types: a tuple [User, Post[]], cleanly destructurable.

const user = await fetchUser();    // attend…
const posts = await fetchPosts();  // …puis attend (alors qu'ils sont indépendants)
// sérialisé sans raison : posts n'avait pas besoin d'attendre user

const [user, posts] = await Promise.all([fetchUser(), fetchPosts()]);
//      ^^^^  ^^^^^ chacun son TYPE : user : User, posts : Post[]
// lancés en parallèle, et Promise.all rend un TUPLE typé position par position

all est tout-ou-rien ; allSettled rend une union discriminée par résultat.all is all-or-nothing; allSettled returns a discriminated union per result.

La surprise qui mord : Promise.all rejette dès la première promesse qui échoue, et jette tous les autres résultats — même ceux qui avaient résolu. C'est voulu (tout ou rien), mais on l'oublie quand les opérations sont indépendantes. allSettled est l'autre régime : il attend que tout se règle, ne rejette jamais, et rend pour chaque élément une union discriminée — fulfilled avec sa value, ou rejected avec sa reason. C'est le Vol 3 qui revient : on narrowe sur status pour traiter chaque sort séparément.The surprise that bites: Promise.all rejects as soon as the first promise fails, and discards all other results — even those that had resolved. It's intentional (all-or-nothing), but forgotten when the operations are independent. allSettled is the other regime: it waits for everything to settle, never rejects, and returns for each element a discriminated union — fulfilled with its value, or rejected with its reason. It's Vol 3 returning: you narrow on status to handle each fate separately.

const [a, b, c] = await Promise.all([fa(), fb(), fc()]);
// ✗ si fb() rejette : Promise.all rejette AUSSITÔT, a et c sont JETÉS
//   on n'obtient ni les succès, ni un détail par opération — tout ou rien

Promise.all court-circuite au premier rejet : le tuple n'est jamais formé, et les résultats des opérations qui avaient réussi sont silencieusement perdus — les opérations elles-mêmes continuent de tourner : rien n'est annulé. Parfait quand on a besoin de tout ; dangereux quand un échec partiel devrait être toléré.Promise.all short-circuits on the first reject: the tuple is never formed, and the results of operations that had succeeded are silently lost — the operations themselves keep running: nothing is cancelled. Perfect when you need everything; dangerous when partial failure should be tolerated.

Quatre combinateurs, quatre types — et l'inférence tuple qui tient à un détail.Four combinators, four types — and the tuple inference that hangs on a detail.

Les quatre combinateurs ont des comportements et des types distincts. all rend un tuple et rejette si l'un rejette. allSettled rend un tuple d'unions discriminées et ne rejette jamais. race rend l'union des types et se règle au premier settled, succès ou échec. any se règle au premier succès, et rejette avec une AggregateError si tous échouent. Le point d'inférence à connaître : all ne préserve le tuple que si le tableau est passé inline ; via une variable de type Promise<X>[], on retombe sur un simple tableau, et les positions sont perdues.The four combinators have distinct behaviors and types. all returns a tuple and rejects if one rejects. allSettled returns a tuple of discriminated unions and never rejects. race returns the union of types and settles on the first settled, success or failure. any settles on the first success, and rejects with an AggregateError if all fail. The inference point to know: all preserves the tuple only if the array is passed inline; through a variable of type Promise<X>[], you fall back to a plain array, and positions are lost.

Promise.all([fa(), fb()])        // [A, B]          rejette si UN rejette
Promise.allSettled([fa(), fb()]) // [Settled<A>, Settled<B>]  ne rejette jamais
Promise.race([fa(), fb()])       // A | B           le PREMIER réglé (succès OU échec)
Promise.any([fa(), fb()])        // A | B           le premier RÉUSSI (sinon AggregateError)

// Inline : TypeScript infère un TUPLE — positions conservées
const r1 = await Promise.all([fa(), fb()]);   // [A, B]  ✓
r1[0];   // A

// Via une variable Promise<X>[] : il infère un TABLEAU — positions perdues
const arr = [fa(), fb()];                      // (Promise<A> | Promise<B>)[]
const r2 = await Promise.all(arr);             // (A | B)[]  ✗ plus de tuple

Promise.all pour des opérations indépendantes : un échec coule tout le reste.Promise.all for independent operations: one failure sinks the rest.

Le contre-exemple : prendre Promise.all par défaut, même quand les opérations sont indépendantes et qu'un échec partiel devrait être toléré. Trois envois d'emails, une notification qui tombe — et tout le all rejette : on ne sait plus qui est parti, on ne peut pas retenter sélectivement, et le résultat d'un succès se retrouve effacé par l'échec d'un voisin — l'envoi, lui, a bien eu lieu. all est fait pour « j'ai besoin de tout, sinon rien ». Pour « je veux le sort de chacun », c'est allSettled. Le bon combinateur est une décision, pas un réflexe.The counter-example: reaching for Promise.all by default, even when the operations are independent and partial failure should be tolerated. Three email sends, one notification drops — and the whole all rejects: you no longer know which went out, you can't retry selectively, and a success's result gets wiped by a neighbor's failure — the send itself did happen. all is for 'I need all of it, or nothing'. For 'I want each one's fate', it's allSettled. The right combinator is a decision, not a reflex.

// 3 envois d'emails indépendants — un échec ne devrait pas faire perdre les autres :
await Promise.all([
  sendEmail(a), sendEmail(b), sendEmail(c),
]);
// ✗ si l'envoi à b rejette, Promise.all rejette : a et c partent quand même (rien
//   n'est annulé), mais on n'a AUCUN détail de qui a réussi. Tout ou rien, là où il fallait du partiel.

Le rejet en bloc efface l'information : impossible de savoir qui a réussi, ni de retenter les seuls ratés. Promise.all n'est pas « lancer plusieurs trucs » — c'est « j'ai besoin de la totalité ». Sur de l'indépendant, c'est le mauvais contrat.The wholesale reject erases information: you can't tell who succeeded, nor retry only the failures. Promise.all isn't "launch several things" — it's "I need the whole lot". On independent ops, it's the wrong contract.