Vad är never-typen och hur möjliggör den exhaustiveness checks?

Question

Accepted Answer

`never` är typen för värden som **aldrig förekommer** — en funktion som aldrig returnerar (kastar eller loopas oändligt), eller en gren som kompilatorn har bevisat är omöjlig. Det är den *tomma* typen: inget värde kan tilldelas till `never` (förutom `never` själv).

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

## Varför never är användbar: exhaustiveness checking

När du begränsar en union ned till ingenting, typifierar TypeScript det återstående värdet som `never`. Du utnyttjar detta för att tvinga hantering av varje fall:

```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 om någon lägger till `{ kind: "triangle"; ... }` till `Shape` men glömmer ett fall, är `s` i default triangle-typen (inte `never`), så `const _exhaustive: never = s` **misslyckas att kompilera** — vilket pekar dig på exakt vilken switch som behöver uppdateras.

## never vs void

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

## Varför det är viktigt

`never` förvandlar "hanterade jag varje fall?" från ett körtidshoppet till en kompileringstidsgaranti.

Det är nyckeln till säker, framtidssäker hantering av diskriminerade unions — lägg till en variant och kompilatorn räknar upp varje plats du måste uppdatera.