How do you get exhaustiveness checking on a union?

A switch over a union is exhaustive when every member has a case. The compiler can prove that only if the default branch receives a value of type never. A small assertNever helper turns that proof into a compile-time error when a new variant appears.

type Status = "idle" | "loading" | "success" | "error";

function assertNever(value: never): never {
  throw new Error("Unhandled status: " + String(value));
}

function label(status: Status): string {
  switch (status) {
    case "idle":
      return "Idle";
    case "loading":
      return "Loading";
    case "success":
      return "Done";
    case "error":
      return "Failed";
    default:
      return assertNever(status);
  }
}

Why it works

• After every case, the remaining type is never
• Passing never to a parameter typed never is valid
• Adding a new member makes the remaining type non-never and breaks the call
• The error points at the missing case, not at the new member
• The same pattern works with if-else chains and reducer actions

Exhaustiveness checking is valuable in reducers, message handlers and any switch over a union that is expected to grow. It turns a silent runtime fallthrough into a build failure. The helper must actually throw at runtime, because the compiler only checks the types.