Discriminated Union — 태그 기반 유니온으로 안전한 분기

// 공통 속성 'type'이 판별자(discriminant)
type Circle = { type: 'circle'; radius: number };
type Square = { type: 'square'; side: number };
type Triangle = { type: 'triangle'; base: number; height: number };

type Shape = Circle | Square | Triangle;

function getArea(shape: Shape): number {
  switch (shape.type) {
    case 'circle':
      // shape: Circle — 자동으로 좁혀짐
      return Math.PI * shape.radius ** 2;
    case 'square':
      // shape: Square
      return shape.side ** 2;
    case 'triangle':
      // shape: Triangle
      return (shape.base * shape.height) / 2;
  }
}

// ❌ 일반 유니온 — 어떤 타입인지 구분이 어려움
type Shape = { radius: number } | { side: number };

function getArea(shape: Shape) {
  if ('radius' in shape) {
    // 동작은 하지만 속성 이름에 의존
  }
}

// ✅ Discriminated Union — 판별자로 명확히 구분
type Shape2 =
  | { type: 'circle'; radius: number }
  | { type: 'square'; side: number };

function getArea2(shape: Shape2) {
  if (shape.type === 'circle') {
    // 명확하고 타입 안전
  }
}

type Shape = Circle | Square | Triangle;

function getArea(shape: Shape): number {
  switch (shape.type) {
    case 'circle':
      return Math.PI * shape.radius ** 2;
    case 'square':
      return shape.side ** 2;
    case 'triangle':
      return (shape.base * shape.height) / 2;
    default:
      // 모든 경우를 처리했으므로 shape: never
      const _exhaustive: never = shape;
      return _exhaustive;
  }
}

// 나중에 새 Shape를 추가하면?
// type Pentagon = { type: 'pentagon'; side: number; };
// type Shape = Circle | Square | Triangle | Pentagon;
// → default에서 에러: Type 'Pentagon' is not assignable to type 'never'

type ApiState<T> =
  | { status: 'idle' }
  | { status: 'loading' }
  | { status: 'success'; data: T }
  | { status: 'error'; error: string };

function renderUser(state: ApiState<{ name: string }>) {
  switch (state.status) {
    case 'idle':
      return '대기 중';
    case 'loading':
      return '로딩 중...';
    case 'success':
      return `이름: ${state.data.name}`; // data에 안전하게 접근
    case 'error':
      return `에러: ${state.error}`; // error에 안전하게 접근
  }
}

type Action =
  | { type: 'INCREMENT'; payload: number }
  | { type: 'DECREMENT'; payload: number }
  | { type: 'RESET' };

function reducer(state: number, action: Action): number {
  switch (action.type) {
    case 'INCREMENT':
      return state + action.payload;
    case 'DECREMENT':
      return state - action.payload;
    case 'RESET':
      return 0;
  }
}

type Result<T, E = Error> =
  | { ok: true; value: T }
  | { ok: false; error: E };

function divide(a: number, b: number): Result<number, string> {
  if (b === 0) {
    return { ok: false, error: '0으로 나눌 수 없습니다' };
  }
  return { ok: true, value: a / b };
}

const result = divide(10, 3);
if (result.ok) {
  console.log(result.value); // number
} else {
  console.log(result.error); // string
}

// 판별자가 여러 속성일 수도 있음
type Event =
  | { source: 'user'; action: 'click'; x: number; y: number }
  | { source: 'user'; action: 'type'; text: string }
  | { source: 'system'; action: 'error'; code: number };

function handleEvent(event: Event) {
  if (event.source === 'user' && event.action === 'click') {
    console.log(event.x, event.y); // OK
  }
}

// ✅ 문자열 리터럴
type A = { kind: 'a'; value: string };

// ✅ 숫자 리터럴
type B = { code: 200; data: any } | { code: 404; message: string };

// ✅ boolean
type C = { success: true; data: any } | { success: false; error: string };

// ❌ string, number 등 넓은 타입은 판별자로 사용 불가
// type Bad = { kind: string; value: any };