never를 사용한 모든 경우 처리 검사

시작하기

완전성 문제

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'?
}

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

새 유니언 구성 요소 추가

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

인라인 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');
  }
}

switch 없이 모든 경우 처리하기

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

제네릭 타입 제약 조건의 never

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

불가능한 상태에 never 사용하기

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

조건부 타입의 never

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

유니언을 통해 전파되는 never

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

assertNever 도우미

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

빠른 확인

복습