Unions & intersections, ou composer les formes Unions & intersections, or composing shapes

Une valeur, plusieurs formes possibles. Une seule à la fois.One value, several possible shapes. Exactly one at a time.

Le typage structurel décrit une forme. Mais le monde réel est fait d'alternatives : une réponse réussie ou en erreur, un identifiant texte ou numérique. L'union A | B note ça directement — « l'une de ces formes, exclusivement » — et c'est la brique de presque toute modélisation honnête.Structural typing describes one shape. But the real world is made of alternatives: a response that succeeded or failed, an id that's text or numeric. The union A | B writes that directly — 'one of these shapes, exclusively' — and it's the brick of almost any honest model.

type Ok  = { status: "ok";    data: string };
type Err = { status: "error"; message: string };

type Result = Ok | Err;   // l'une OU l'autre — jamais entre les deux

function code(r: Result) {
  return r.status;   // ✓ status existe dans les DEUX formes → toujours lisible
}

Une union élargit les valeurs. Et rétrécit ce qu'on peut faire.A union widens the values. And narrows what you can do.

L'intuition dit : « string | number, donc je peux traiter un string OU un number, à ma guise ». Faux. Tant qu'on ne sait pas laquelle des deux on tient, TypeScript n'autorise que ce que les deux formes ont en commun. Réunir des possibilités, c'est restreindre les opérations sûres.Intuition says: 'string | number, so I can treat it as a string OR a number, as I please'. Wrong. Until you know which of the two you hold, TypeScript allows only what both shapes share. Joining possibilities restricts the safe operations.

function fmt(x: string | number) {
  return x.toUpperCase();
  //       ^^^^^^^^^^^
  // error: Property 'toUpperCase' does not exist on type 'string | number'.
  //        Property 'toUpperCase' does not exist on type 'number'.
}

toUpperCase existe sur string, pas sur number. Comme x pourrait être l'un ou l'autre, TypeScript refuse : il ne garantit que les membres présents dans toutes les branches de l'union. C'est exactement le crash x.toUpperCase is not a function qu'on évite.toUpperCase exists on string, not on number. Since x could be either one, TypeScript refuses: it only guarantees members present in every branch of the union. That's exactly the x.toUpperCase is not a function crash you avoid.

Réunir les valeurs, c'est croiser les champs. À l'envers de l'intuition.Joining the values intersects the fields. Backwards from intuition.

Voici le contre-sens qui surprend tout le monde. L'union des valeurs (A | B) donne l'intersection des champs accessibles ; l'intersection des valeurs (A & B) donne l'union des champs. Plus on autorise de valeurs, moins on peut toucher de champs sûrement — et inversement.Here's the twist that surprises everyone. Union of values (A | B) yields the intersection of accessible fields; intersection of values (A & B) yields the union of fields. The more values you allow, the fewer fields you can safely touch — and vice versa.

type A = { id: number; a: string };
type B = { id: number; b: boolean };

type U = A | B;   // accès : seulement { id } — le commun aux deux
type I = A & B;   // accès : { id; a; b } — tout des deux

declare const u: U;
u.id;   // ✓ présent dans A ET dans B
u.a;    // ✗ pas garanti — u pourrait être un B

declare const i: I;
i.id; i.a; i.b;   // ✓ i est A et B à la fois

Le & mis pour « fusionner ». Le sac d'optionnels mis pour « les cas ».The & used to "merge". The bag of optionals used for "the cases".

Deux pièges symétriques. D'abord, l'intersection appliquée à des types qui n'ont aucune valeur commune : le résultat est never, un type que rien ne satisfait. Ensuite, l'erreur la plus coûteuse : modéliser des alternatives avec un seul objet plein de champs optionnels — qui laisse exister tous les états illégaux.Two symmetric traps. First, intersection applied to types with no common value: the result is never, a type nothing satisfies. Then, the costliest mistake: modeling alternatives with a single object full of optional fields — which lets every illegal state exist.

type Weird = string & number;        // never — aucune valeur n'est les deux
type Bad   = { x: number } & { x: string };
//     i.x est number & string = never : i.x ne peut JAMAIS être lu

Aucune valeur n'est à la fois un string et un number : leur intersection est never. Même chose pour deux champs x de types inconciliables. Quand un & donne never sans qu'on l'ait voulu, c'est presque toujours qu'on voulait un |.No value is both a string and a number: their intersection is never. Same for two x fields of irreconcilable types. When a & yields never unintentionally, you almost always wanted a |.

// L'anti-pattern : un sac d'optionnels
type Resp = { ok: boolean; data?: string; error?: string };

const r: Resp = { ok: true, error: "boom" };  // ✓ compile…
//   « réussi » ET porteur d'une erreur, sans data : un état illégal accepté

Avec un seul objet, data et error peuvent être présents ensemble, ou absents tous les deux. Le type décrit plus d'états que la réalité n'en autorise — et chaque état parasite est un if défensif à écrire, ou un bug.With one object, data and error can both be present, or both absent. The type describes more states than reality allows — and each spurious state is a defensive if to write, or a bug.