Hva er never-typen og hvordan gjør den exhaustiveness-sjekker mulige?

Question

Accepted Answer

`never` er typen for verdier som **aldri forekommer** — en funksjon som aldri returnerer (kaster eller løkker uendelig), eller en gren som kompilatoren har bevist er umulig. Det er den *tomme* typen: ingen verdi kan tilordnes `never` (bortsett fra `never` selv).

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

## Hvorfor never er nyttig: exhaustiveness-sjekking

Når du snever inn en union til ingenting, gir TypeScript den gjenværende verdien typen `never`. Du utnytter dette til å tvinge håndtering av hvert tilfelle:

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

Nå hvis noen legger til `{ kind: "triangle"; ... }` til `Shape` men glemmer et tilfelle, er `s` i default-grenen triangle-typen (ikke `never`), så `const _exhaustive: never = s` **mislykkes å kompilere** — og peker deg direkte til switch-uttrykket som må oppdateres.

## never vs void

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

## Hvorfor det er viktig

`never` gjør "håndterte jeg hvert tilfelle?" fra et runtime-håp til en kompileringstidsgaranti.

Det er nøkkelen til sikker, fremtidssikker håndtering av diskriminerte unioner — legg til en variant og kompilatoren oppregner hvert sted du må oppdatere.