never & l'exhaustivité, ou le cas qui ne peut pas arriver never & exhaustiveness, or the case that cannot happen

L'union pose les formes. Mais rien ne t'oblige à toutes les traiter.The union lays down the shapes. But nothing forces you to handle them all.

C'est la porte laissée ouverte par le numéro précédent. Une union discriminée décrit exactement les formes légales — mais le switch qui les parcourt peut en oublier une, et compiler quand même. Pire : le jour où tu ajoutes un membre, tous les switch déjà écrits l'ignorent en silence. Le bug n'est pas à l'écriture du switch ; il naît six mois plus tard, à l'ajout d'une variante. never est l'outil qui transforme cet oubli en erreur de compilation.This is the door left open by the previous issue. A discriminated union describes exactly the legal shapes — but the switch that walks them can forget one, and still compile. Worse: the day you add a member, every switch already written ignores it silently. The bug isn't in writing the switch; it's born six months later, when a variant is added. never is the tool that turns that omission into a compile error.

type Shape =
  | { kind: "circle"; r: number }
  | { kind: "rect"; w: number; h: number }
  | { kind: "triangle"; b: number; h: number };   // ← ajouté aujourd'hui

function area(s: Shape) {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "rect":   return s.w * s.h;
    // triangle oublié : aucune erreur ICI — area est inférée number | undefined
  }
}   // 💥 l'erreur surgit loin, à l'usage — ou jamais : `${area(t)} m²` affiche « undefined m² »

function area(s: Shape): number {
  switch (s.kind) {
    case "circle":   return Math.PI * s.r ** 2;
    case "rect":     return s.w * s.h;
    case "triangle": return (s.b * s.h) / 2;
    default: {
      const _exhaustive: never = s;   // ✗ si un cas manque, s n'est PAS 'never'
      return _exhaustive;             //   → erreur de compilation, pointée sur le cas oublié
    }
  }
}

never est le type sans aucune valeur. Rien ne lui est assignable — et c'est toute l'astuce.never is the type with no value at all. Nothing is assignable to it — and that's the whole trick.

Le narrowing du Vol 2 rétrécit une union membre par membre. Quand toutes les branches d'un switch sont traitées, il ne reste plus rien à éliminer : dans le default, le type de la variable devient never — l'ensemble vide. Lui assigner never compile. Mais s'il reste un cas non traité, la variable garde ce membre, et never refuse de l'accueillir. L'erreur n'est pas un effet de bord : c'est exactement le signal qu'un cas a été oublié.Vol 2's narrowing shrinks a union member by member. When every branch of a switch is handled, there's nothing left to eliminate: in the default, the variable's type becomes never — the empty set. Assigning never to it compiles. But if a case remains unhandled, the variable keeps that member, and never refuses to receive it. The error isn't a side effect: it's precisely the signal that a case was forgotten.

function area(s: Shape): number {
  switch (s.kind) {
    case "circle":   return Math.PI * s.r ** 2;
    case "rect":     return s.w * s.h;
    case "triangle": return (s.b * s.h) / 2;
    default:
      // les trois membres sont éliminés : ici s : never
      const _: never = s;   // ✓ compile — never est assignable à never
      return _;
  }
}

Chaque case élimine un membre. Au default, l'union n'a plus de membre vivant : son type est never. L'affectation const _: never = s passe, parce que la seule chose assignable à never, c'est never. Le compilateur confirme : cette branche ne peut pas arriver.Each case eliminates a member. At the default, the union has no living member left: its type is never. The assignment const _: never = s passes, because the only thing assignable to never is never. The compiler confirms: this branch cannot happen.

Une fonction qui n'accepte que l'impossible — et garde la porte aux deux étages.A function that accepts only the impossible — and guards the door on both floors.

On range la garde dans un helper : assertNever(x: never). Comme son paramètre est de type never, on ne peut l'appeler qu'avec une valeur que le narrowing a réduite à never — c'est-à-dire dans un default vraiment inatteignable. Si un cas manque, la valeur n'est pas never, et l'appel ne compile pas. Bonus : à l'exécution, si une valeur aberrante arrivait quand même, la fonction lève au lieu de continuer en silence.You stash the guard in a helper: assertNever(x: never). Since its parameter is typed never, you can only call it with a value narrowing has reduced to never — that is, in a truly unreachable default. If a case is missing, the value isn't never, and the call won't compile. Bonus: at runtime, should an aberrant value slip through anyway, the function throws instead of continuing silently.

// Une seule fois dans le projet : la garde réutilisable.
function assertNever(x: never): never {
  throw new Error("Cas non géré : " + JSON.stringify(x));
}

function label(s: Shape): string {
  switch (s.kind) {
    case "circle":   return "cercle";
    case "rect":     return "rectangle";
    case "triangle": return "triangle";
    default: return assertNever(s);   // ✓ compile SI tous les cas sont couverts
  }
}
// Ajoute { kind: "hexagon" } à Shape → cette ligne ne compile plus.

Le default fourre-tout qui « gère » tout — et rebouche le trou.The catch-all default that "handles" everything — and reseals the hole.

Le piège n'est pas dans never, il est dans le réflexe défensif qu'il combat. Un default qui renvoie une valeur de repli — « inconnu », 0, null — a l'air prudent : plus de crash. Mais il avale aussi tous les cas futurs. La valeur narrowée n'atteint jamais never, l'exhaustivité ne se déclenche pas, et ajouter un membre ne casse plus rien. Tu as échangé une erreur de compilation bruyante contre un bug silencieux — exactement le marché qu'on refusait.The trap isn't in never, it's in the defensive reflex it fights. A default that returns a fallback — 'unknown', 0, null — looks prudent: no more crash. But it also swallows every future case. The narrowed value never reaches never, exhaustiveness never fires, and adding a member breaks nothing. You've traded a loud compile error for a silent bug — exactly the deal we were refusing.

function label(s: Shape): string {
  switch (s.kind) {
    case "circle": return "cercle";
    case "rect":   return "rectangle";
    default: return "inconnu";   // ✗ avale TOUT le reste — y compris triangle
  }
}
// Ajoute { kind: "hexagon" } → toujours vert. Le default fourre-tout
// a rebouché le trou : l'oubli est redevenu silencieux.

Le default: return "inconnu" capture triangle et tout membre ajouté plus tard. La valeur n'atteint jamais never : le filet d'exhaustivité est débranché, sans le moindre avertissement. C'est le contre-exemple obligatoire : un default qui produit une valeur annule tout l'intérêt de never.The default: return "unknown" captures triangle and any member added later. The value never reaches never: the exhaustiveness net is unplugged, without a single warning. This is the mandatory counter-example: a default that produces a value cancels the whole point of never.