function greet(value: string | null): string {
  // At this point: value is string | null

  if (value === null) {
    // Inside this branch: value is null
    return 'Hello, stranger'
  }

  // After the null branch exits: value is string
  return `Hello, ${value.toUpperCase()}` // ✅ Safe — no null check needed
}

function format(value: string | number | boolean): string {
  if (typeof value === 'string') {
    return value.toUpperCase()   // value: string
  }
  if (typeof value === 'number') {
    return value.toFixed(2)      // value: number
  }
  // value: boolean — only remaining member
  return value ? 'yes' : 'no'
}

function handleError(error: Error | string): string {
  if (error instanceof TypeError) {
    return `Type error: ${error.message}`  // error: TypeError
  }
  if (error instanceof Error) {
    return `Error: ${error.message}`       // error: Error (but not TypeError — already handled)
  }
  return error                             // error: string
}

type Cat = { meow(): void }
type Dog = { bark(): void }

function speak(animal: Cat | Dog): void {
  if ('meow' in animal) {
    animal.meow()  // animal: Cat
  } else {
    animal.bark()  // animal: Dog
  }
}

function printName(name: string | null | undefined): void {
  if (name) {
    // name: string — null and undefined are falsy and have been eliminated
    console.log(name.toUpperCase())
  }
}

// ❌ Without a discriminant — narrowing requires checking for optional properties
type Shape =
  | { radius: number }     // circle?
  | { width: number; height: number }  // rectangle?

// ✅ With a literal discriminant — narrowing is precise and readable
type Circle   = { kind: 'circle';    radius: number }
type Rectangle = { kind: 'rectangle'; width: number; height: number }
type Triangle = { kind: 'triangle';  base: number; height: number }
type Shape = Circle | Rectangle | Triangle

function area(shape: Shape): number {
  switch (shape.kind) {
    case 'circle':
      return Math.PI * shape.radius ** 2  // shape: Circle
    case 'rectangle':
      return shape.width * shape.height   // shape: Rectangle
    case 'triangle':
      return 0.5 * shape.base * shape.height  // shape: Triangle
  }
}

// Without a type predicate — TypeScript does not know what `isUser` proves
function isUser(value: unknown): boolean {
  return typeof value === 'object' && value !== null && 'name' in value
}

const data: unknown = fetchUser()
if (isUser(data)) {
  console.log(data.name)  // ❌ Error: 'name' does not exist on type 'unknown'
}

// ✅ With a type predicate — the return type annotation `x is User` teaches CFA
interface User { name: string; email: string }

function isUser(value: unknown): value is User {
  return (
    typeof value === 'object' &&
    value !== null &&
    typeof (value as any).name === 'string' &&
    typeof (value as any).email === 'string'
  )
}

const data: unknown = fetchUser()
if (isUser(data)) {
  console.log(data.name)  // ✅ data: User — type is narrowed
}

// ❌ A regular function cannot narrow the type for the caller
function assertString(val: unknown): void {
  if (typeof val !== 'string') throw new Error('Not a string')
}

const input: unknown = getInput()
assertString(input)
input.toUpperCase()  // ❌ Error: input is still `unknown`

// ✅ An assertion function with `asserts` narrows for all following code
function assertString(val: unknown): asserts val is string {
  if (typeof val !== 'string') throw new Error(`Expected string, got ${typeof val}`)
}

const input: unknown = getInput()
assertString(input)
input.toUpperCase()  // ✅ input is narrowed to `string` for all code following the assertion

type Status = 'idle' | 'loading' | 'success' | 'error'

function handleStatus(status: Status): string {
  switch (status) {
    case 'idle':    return 'Waiting...'
    case 'loading': return 'Loading...'
    case 'success': return 'Done!'
    case 'error':   return 'Failed!'
    default:
      // If 'cancelled' is added to Status without a case, this line errors:
      // Type 'string' is not assignable to type 'never'.
      const _exhaustive: never = status
      throw new Error(`Unhandled status: ${_exhaustive}`)
  }
}