Qu'est-ce que le type never et comment permet-il les vérifications d'exhaustivité ?

Question

Accepted Answer

`never` est le type des valeurs qui **ne se produisent jamais** — une fonction qui ne retourne jamais (lève une exception ou boucle indéfiniment), ou une branche que le compilateur a prouvée impossible. C'est le type *vide* : aucune valeur n'est assignable à `never` (sauf `never` lui-même).

```ts
function fail(msg: string): never { throw new Error(msg); } // never returns
function loop(): never { while (true) {} }
```

## Pourquoi never est utile : vérification d'exhaustivité

Quand vous réduisez une union à rien, TypeScript tape la valeur restante comme `never`. Vous exploitez cela pour forcer la gestion de chaque cas :

```ts
type Shape =
  | { kind: "circle"; r: number }
  | { kind: "square"; side: number };

function area(s: Shape): number {
  switch (s.kind) {
    case "circle": return Math.PI * s.r ** 2;
    case "square": return s.side ** 2;
    default:
      // if all cases are handled, s is `never` here — assignment OK
      const _exhaustive: never = s;
      return _exhaustive;
  }
}
```

Maintenant, si quelqu'un ajoute `{ kind: "triangle"; ... }` à `Shape` mais oublie un cas, `s` dans le défaut est le type triangle (pas `never`), donc `const _exhaustive: never = s` **échoue à compiler** — pointant exactement le switch qui doit être mis à jour.

## never vs void

```ts
function a(): void {}   // returns normally, just no value
function b(): never { throw "x"; } // never returns at all
```

## Pourquoi c'est important

`never` transforme « ai-je traité tous les cas ? » d'un espoir à l'exécution en une garantie à la compilation.

C'est la clé de la gestion sûre et pérenne des unions discriminées — ajoutez une variante et le compilateur énumère chaque endroit que vous devez mettre à jour.