What is the never type in TypeScript, and how do you use it for exhaustive checks?

Think of a hostel warden ticking off students at night roll call. Each name on the list is ticked when the student is found. If, at the end, the "not yet found" list is empty, everyone is accounted for. If someone is still on it, the warden raises an alarm.

never is TypeScript's "nobody left" type. When you handle each member of a union one by one, TypeScript removes it from the remaining type. After the last case, the remaining type is never. If you write code that says "this must be never here", and someone later adds a new member to the union without handling it, the compiler raises the alarm.

type PaymentMethod =
  | { kind: "upi"; upiId: string }
  | { kind: "card"; last4: string }
  | { kind: "netbanking"; bank: string };

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

function describe(method: PaymentMethod): string {
  switch (method.kind) {
    case "upi":
      return `UPI ${method.upiId}`;
    case "card":
      return `Card ending ${method.last4}`;
    case "netbanking":
      return `Net banking via ${method.bank}`;
    default:
      return assertNever(method); // method is never here
  }
}

Now a teammate adds | { kind: "wallet"; provider: string } to PaymentMethod. Without touching describe, the build fails at assertNever(method) with an error saying the wallet type is not assignable to never. The bug is caught at compile time, not by a customer.

• Bottom type: never is assignable to every type, but no type (other than never itself) is assignable to never. That is why assigning a leftover value to a never parameter is an error unless the leftover really is empty.
• Narrowing: in the switch, each case removes one member from the union. In default, nothing is left, so method has type never.
• Functions that never return: a function that always throws, or loops forever, has return type never. Because assertNever returns never, return assertNever(method) satisfies the string return type.
• Impossible types: string & number is never, and an object property with conflicting types in an intersection becomes never.
• In conditional types: never acts like an empty union, so it disappears. Exclude<T, U> is defined as T extends U ? never : T, which keeps only the members not in U.

assertNever also protects at runtime: if bad data from an API slips past the types, you get a clear error instead of undefined silently returned.

• Reducers and state machines with an action.type or state.status field.
• Mapping every enum or literal value to a label, icon or handler.
• Library types: filtering keys with conditional types, such as getting only the keys of an object whose values are functions.

• Confusing never with void. A void function finishes and returns nothing useful; a never function does not finish normally at all.
• Adding a default that returns a fallback value. It hides new cases instead of reporting them.
• Using if chains with a final else that assumes the last case. A new member silently falls into that else; an explicit check plus assertNever catches it.
• Writing the check as const x: never = value; and then disabling the "unused variable" lint rule. A small assertNever helper is clearer and also throws at runtime.

• What is the difference between never, void and unknown?
• How is Exclude implemented?
• Why does string & number become never?
• How does a Record over a literal union also enforce exhaustiveness?