What is the never type and how does it enable exhaustiveness checks?

Question

Accepted Answer

`never` is the type of values that **never occur** — a function that never returns (throws or loops forever), or a branch the compiler has proven is impossible. It's the *empty* type: no value is assignable to `never` (except `never` itself).

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

## Why never is useful: exhaustiveness checking

When you narrow a union down to nothing, TypeScript types the remaining value as `never`. You exploit this to force handling of every case:

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

Now if someone adds `{ kind: "triangle"; ... }` to `Shape` but forgets a case, `s` in the default is the triangle type (not `never`), so `const _exhaustive: never = s` **fails to compile** — pointing you at exactly the switch that needs updating.

## never vs void

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

## Why it matters

`never` turns "did I handle every case?" from a runtime hope into a compile-time guarantee.

It's the key to safe, future-proof handling of discriminated unions — add a variant and the compiler enumerates every place you must update.