Wat is het never type en hoe maakt het exhaustiveness checks mogelijk?

Question

Accepted Answer

`never` is het type van waarden die **nooit voorkomen** — een functie die nooit terugkeert (throws of loopt voor altijd), of een branch die de compiler heeft bewezen onmogelijk is. Het is het *lege* type: geen waarde kan aan `never` worden toegewezen (behalve `never` zelf).

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

## Waarom het belangrijk is

Wanneer je een union tot niets nauwkeurig maakt, typeert TypeScript de resterende waarde als `never`. Je gebruikt dit om af te dwingen dat elk geval wordt afgehandeld:

```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;
  }
}
```

Nu als iemand `{ kind: "triangle"; ... }` aan `Shape` toevoegt maar een geval vergeet, is `s` in de default het triangle type (niet `never`), dus `const _exhaustive: never = s` **faalt bij compilatie** — wijzend op precies welke switch moet worden bijgewerkt.

## never versus void

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

## Waarom het belangrijk is

`never` verandert "heb ik elk geval afgehandeld?" van een runtime hoop in een compile-time garantie.

Het is de sleutel tot veilig, toekomstsbestendig omgaan met gediscrimineerde unies — voeg een variant toe en de compiler somt op waar je moet bijwerken.