Patterns

How do I get a compile error when someone adds a case to a union and forgets to handle it?

Narrow every case and assign what is left to never. Once the union grows, what is left is no longer nothing, and the assignment fails.

The recipe

type Shape =
  | { kind: 'circle'; r: number }
  | { kind: 'square'; side: number }

function assertNever(value: never): never {
  throw new Error(`Unhandled: ${JSON.stringify(value)}`)
}

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.r ** 2
    case 'square':
      return shape.side ** 2
    default:
      return assertNever(shape)
  }
}

The build compiles this and checks each result below.

How it works

01
```
function assertNever(value: never): never {
```
A parameter typed never accepts nothing. The only value you can pass is one the compiler has already proved impossible.
02
```
return assertNever(shape)
```
By the default branch every known case has been returned from, so shape has narrowed to never and this compiles. Add a third shape and it stops compiling — at this line, naming the type you forgot.
03
```
throw new Error
```
It throws rather than returning, because a value that was supposed to be impossible arriving at run time is a bug, not a case to absorb.

What you get

```
ReturnType<typeof area>
```
→number
```
Shape['kind']
```
→"circle" | "square"
```
Extract<Shape, { kind: 'circle' }>
```
→{ kind: "circle"; r: number; }
The discriminant is what makes narrowing possible — one literal property every member has and no two share.

Where it goes wrong

It only works if every case returns or throws. A break that falls through to the default leaves shape un-narrowed, and the check quietly stops checking anything.

Takeaway

This is the single highest-value pattern in the language. It converts "we forgot to handle the new case" from a production incident into a compile error.