O que é o tipo `never` e como ele permite verificações de exhaustiveness?

Question

Accepted Answer

`never` é o tipo de valores que **nunca ocorrem** — uma função que nunca retorna (lança ou entra em loop infinito), ou um branch que o compilador provou ser impossível. É o tipo *vazio*: nenhum valor pode ser atribuído a `never` (exceto `never` em si).

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

## Por que never é útil: verificação de exhaustiveness

Quando você restringe uma union até nada, TypeScript tipifica o valor restante como `never`. Você aproveita isso para forçar o tratamento de cada caso:

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

Agora se alguém adicionar `{ kind: "triangle"; ... }` a `Shape` mas esquecer um caso, `s` no default é o tipo triangle (não `never`), então `const _exhaustive: never = s` **falha ao compilar** — apontando exatamente para o switch que precisa ser atualizado.

## never vs void

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

## Por que isso importa

`never` transforma "tratei todos os casos?" de uma esperança em tempo de execução em uma garantia em tempo de compilação.

É a chave para manipulação segura e à prova de futuro de unions discriminadas — adicione uma variante e o compilador enumera todos os lugares que você deve atualizar.