match

function Process(result: LlmResult) -> string {
  if (result == null) {
    return "No result"
  }
  if (result instanceof Success) {
    if (result.score >= 0.9) {
      return "High confidence"
    }
    return "Low confidence"
  }
  if (result instanceof Failure) {
    return "Failed: " + result.reason
  }
  // What if we forget a case? No compiler help.
}

match (x) {
  s: Success => "got success: " + s.data   // s is bound, type is Success
  _: Failure => "got failure"              // _ is bound but discarded
  value1 => "literal match"                // value1 is a literal or catch-all
}

match (result) {
  _: Success => "success"     // _ bound to Success, but dropped
  other => "other: " + other  // other bound and usable
}

match (x) {
  _: int => "integer"
  _: string => "string"
  other => "something else: " + other  // catch-all, binds to 'other'
}

// Or using _ as catch-all (value discarded):
match (x) {
  _: int => "integer"
  _ => "not an integer"  // catch-all, value discarded
}

// All equivalent:
x: int | bool
x: (int | bool)
x: (int) | (bool)

// Complex unions:
result: Success | Failure
code: 200 | 201 | 204
cmd: "start" | "stop"

class Success { data string }
class Failure { reason string }
class Pending { eta int }

match (result) {
  x: Success | Failure => {
    // x has type `Success | Failure`, NOT some supertype
    handle(x)
  }
  _: Pending => "pending"
}

type Result = Success | Failure | null

// Exhaustive via explicit patterns:
match (result) {
  _: Success => "ok"
  _: Failure => "error"
  null => "nothing"
}

// Exhaustive via catch-all:
match (result) {
  _: Success => "ok"
  _ => "not success"  // covers Failure and null
}

// NOT exhaustive — compile error:
match (result) {
  _: Success => "ok"
  _: Failure => "error"
  // Error: 'null' not handled
}

match_expr     := 'match' '(' expr ')' '{' match_arm+ '}'
match_arm      := pattern guard? '=>' arm_body
pattern        := binding_pattern | literal_pattern | union_pattern
binding_pattern := IDENT (':' type_expr)?
literal_pattern := 'null' | 'true' | 'false' | INTEGER | FLOAT | STRING
union_pattern  := (literal_pattern | enum_variant) ('|' (literal_pattern | enum_variant))*
enum_variant   := IDENT '.' IDENT
guard          := 'if' expr
arm_body       := expr | block_expr
type_expr      := ... (existing type expression grammar)

x: int | bool    // parsed as x: (int | bool)
x: (int | bool)  // same as above
x: (int) | (bool) // same as above

class Success { data string, score float }
class Failure { reason string, code int }
type Result = Success | Failure | null

function Process(result: Result) -> string {
  return match (result) {
    null => "No result"
    s: Success => "Got: " + s.data
    f: Failure => "Error: " + f.reason
  }
}

function Classify(result: Result) -> string {
  return match (result) {
    null => "none"

    s: Success if s.score >= 0.9 => "excellent: " + s.data
    s: Success if s.score >= 0.7 => "good: " + s.data
    s: Success => "marginal: " + s.data

    f: Failure if f.code >= 500 => "server error: " + f.reason
    f: Failure => "client error: " + f.reason
  }
}

enum Status { Active, Inactive, Pending, Archived }

function Describe(s: Status) -> string {
  return match (s) {
    Status.Active => "User is active"
    Status.Inactive => "User is inactive"
    Status.Pending => "Awaiting approval"
    Status.Archived => "User archived"
  }
}

type HttpSuccess = 200 | 201 | 204
type HttpError = 400 | 404 | 500

function DescribeStatus(code: int) -> string {
  return match (code) {
    200 | 201 => "Success with content"
    204 => "Success, no content"
    400 | 404 => "Client error"
    500 => "Server error"
    _ => "Unknown status: " + code
  }
}

enum Status { Active, Inactive, Pending }

function IsActionable(s: Status) -> bool {
  return match (s) {
    Status.Active | Status.Pending => true
    Status.Inactive => false
  }
}

type Primitive = string | int | bool
type Complex = User | Image
type Any = Primitive | Complex | null

function Categorize(val: Any) -> string {
  return match (val) {
    null => "nothing"
    p: Primitive => "primitive value"  // p has type string | int | bool
    c: Complex => "complex object"     // c has type User | Image
  }
}

class Request { auth: ApiKey | OAuth | null, endpoint: string }

function Authorize(req: Request) -> string {
  return match (req.auth) {
    null => "No auth for " + req.endpoint

    a: ApiKey => match (a.key) {
      k: string if k.startsWith("prod_") => "Production key"
      _ => "Dev key"
    }

    o: OAuth if o.expires > now() => "Valid OAuth"
    _: OAuth => "Expired OAuth"
  }
}

match (status) {
  _: Error => {
    log("Error occurred")
    metrics.increment("errors")
    "Failed"  // return value
  }
  _ => "OK"
}

type T = A | B | C

// OK: all explicit
match (x) {
  _: A => "a"
  _: B => "b"
  _: C => "c"
}

// OK: catch-all covers B and C
match (x) {
  _: A => "a"
  _ => "not a"
}

// ERROR: C not covered
match (x) {
  _: A => "a"
  _: B => "b"
}

// ERROR: unreachable arm (B already covered by catch-all)
match (x) {
  _: A => "a"
  _ => "other"
  _: B => "b"  // unreachable!
}

type T = string | int | null

match (x) {
  s: string => s.length()    // s is string, not string | int | null
  n: int => n + 1            // n is int
  null => 0
}

match (x) {
  a: A => use(a)   // a is A
  a: B => use(a)   // a is B (different a, shadows previous)
}
// a is not accessible here

// NOT YET SUPPORTED:
match (user) {
  User { name: "Admin" } => "admin"
  User { name, age } => name + " is " + age
}

// NOT SUPPORTED:
match (x) {
  _: A | _: B => "a or b"  // can't have multiple binding patterns
}

// INSTEAD, use type union:
match (x) {
  _: A | B => "a or b"  // A | B is a type expression
}

// NOT SUPPORTED:
match (x) {
  s @ Success { data } => use(s, data)
}

// Source:
match (x) {
  s: Success if s.score > 0.9 => "high"
  s: Success => "low"
  _: Failure => "failed"
}

// Desugared (conceptually):
{
  let $scrut = x
  if ($scrut instanceof Success) {
    let s = $scrut
    if (s.score > 0.9) {
      "high"
    } else {
      "low"
    }
  } else if ($scrut instanceof Failure) {
    "failed"
  } else {
    // unreachable if exhaustive
  }
}

// These are parsed identically at the syntax level:
_ => "fallback"
other => "fallback"

// The difference is semantic: _ is dropped, other is usable

// CORRECT: Enum variant as value pattern (no binding needed)
Status.Active => "active"
Status.Active | Status.Pending => "actionable"

// INCORRECT: Cannot use enum variant after `:` — it's not a type!
// x: Status.Active => ...  // ERROR: Status.Active is a value, not a type

enum Status { Active, Inactive, Pending }

match (s) {
  // Match specific variants as values (no binding):
  Status.Active => "active"
  Status.Inactive => "inactive"
  Status.Pending => "pending"
}

// Or match the enum type with binding and use guards:
match (s) {
  x: Status if x == Status.Active => "active: " + x
  _: Status => "other status"
}

match (x) {
  s: Success if s.score > 0.9 => "high"
  // ERROR: Success not exhaustively covered!
}

match (expensiveCall()) {
  _: A => ...
  _: B => ...
}

// Must compile to:
let $scrut = expensiveCall()
if ($scrut instanceof A) { ... }
else if ($scrut instanceof B) { ... }

// NOT:
if (expensiveCall() instanceof A) { ... }  // Wrong: multiple calls!

class Success { data string }
class Failure { reason string }
class Pending { eta int }

match (result) {
  x: Success | Failure => {
    // x has type: Success | Failure
    // NOT some broader type
  }
  _: Pending => "pending"
}

match (x) {
  _ => "catch all"
  _: Success => "never reached"  // ERROR: unreachable
}

match (x) {
  _: A => "a"      // matches A
  _: A | B => "ab" // only matches B (A already handled)
}