Comprobación de exhaustividad con never

Bienvenido

El problema de la exhaustividad

type Shape = 'circle' | 'square';
function area(s: Shape): number {
  if (s === 'circle') return 3.14;
  if (s === 'square') return 1;
  // What if we add 'triangle'?
}

El patrón de exhaustividad con never

function assertNever(x: never): never {
  throw new Error('Unexpected value: ' + x);
}
function area(s: Shape): number {
  switch (s) {
    case 'circle': return 3.14;
    case 'square': return 1;
    default: return assertNever(s);
  }
}

Añadir un nuevo miembro a una unión

type Shape = 'circle' | 'square' | 'triangle';
// Now TypeScript errors on assertNever(s) because s is 'triangle'
// — it's not never!

Comprobación inline con never

function handle(shape: Shape): string {
  switch (shape.kind) {
    case 'circle': return 'circle';
    case 'square': return 'square';
    default:
      const _: never = shape; // Error if not exhaustive
      throw new Error('Unknown shape');
  }
}

Exhaustividad sin switch

function process(action: Action): void {
  if (action.type === 'A') { /* ... */ }
  else if (action.type === 'B') { /* ... */ }
  else {
    const _: never = action; // exhaustive
  }
}

never en restricciones de tipos genéricos

type NonNullable<T> = T extends null | undefined ? never : T;
// Removes null and undefined from T

Usar never para estados imposibles

type State<T> =
  | { kind: 'loading' }
  | { kind: 'success'; data: T }
  | { kind: 'error'; msg: string };
// There should never be a state with kind: 'unknown'

never en tipos condicionales

type NonFunctions<T> = {
  [K in keyof T]: T[K] extends Function ? never : K
}[keyof T];
// Returns keys whose values are not functions

never se propaga por las uniones

type T = string | never; // string
type U = never | number | never; // number

El helper assertNever

function assertNever(value: never, message?: string): never {
  throw new Error(message ?? `Unhandled: ${JSON.stringify(value)}`);
}

Comprobación rápida

Resumen