Qu'est-ce qu'une union discriminée et pourquoi est-elle puissante?

Question

Accepted Answer

Une **union discriminée (étiquetée)** est une union de types d'objets qui partagent tous un champ littéral commun — le **discriminant** — que le compilateur utilise pour distinguer les variantes et affiner en toute sécurité.

```ts
type Result =
  | { status: "loading" }
  | { status: "success"; data: string }
  | { status: "error"; message: string };
```

Chaque membre a un champ `status` littéral. Le vérifier affine à exactement une variante, déverrouillant les champs de cette variante :

```ts
function render(r: Result) {
  switch (r.status) {
    case "loading": return "...";
    case "success": return r.data;     // ✅ data exists only here
    case "error":   return r.message;  // ✅ message exists only here
  }
}
```

Si vous tentez d'accéder à `r.data` dans le cas `loading`, c'est une erreur de compilation — le système de types rend les combinaisons invalides *non représentables*.

## Vérification de l'exhaustivité

```ts
function render2(r: Result): string {
  switch (r.status) {
    case "loading": return "...";
    case "success": return r.data;
    case "error":   return r.message;
    default:
      const _exhaustive: never = r; // ✅ if you add a variant and forget a case, this errors
      return _exhaustive;
  }
}
```

L'attribution `never` vous force à traiter chaque cas — ajoutez un nouveau status et le compilateur vous indique chaque switch qui doit être mis à jour.

## Pourquoi c'est important

Les unions discriminées sont le moyen idiomatique de modéliser l'état (loading/success/error), les événements/actions (Redux reducers) et toutes les données "une parmi plusieurs formes".

Elles rendent les états illégaux impossibles et, avec l'astuce `never`, vous donnent une vérification d'exhaustivité au moment de la compilation — un énorme gain de sécurité par rapport à la modélisation vague avec `boolean`/champs optionnels.