Variable Match

Type declaration

• • <T extends unknown, R extends unknown>(value: T): Match<T, R>

  • Create a new pattern match expression

    Type Parameters

    • T extends unknown
    • R extends unknown

    Parameters

    • value: T

    Returns Match<T, R>

    Example

    const result = Match(httpStatus)
      .case(s => s >= 200 && s < 300, "Success")
      .case(s => s >= 400 && s < 500, "Client Error")
      .case(s => s >= 500, "Server Error")
      .default("Unknown")
    Copy

• builder: <T extends unknown, R extends unknown>() => {
      case: (
          pattern: Pattern<T>,
          result: PatternResult<T, R>,
      ) => { case: (pattern: Pattern<T>, result: PatternResult<T, R>) => any; when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => any; default: (result: PatternResult<T, R>) => { build: () => (value: T) => R; }; };
      default: (result: PatternResult<T, R>) => { build: () => (value: T) => R };
      when: (
          guard: (value: T) => boolean,
          result: PatternResult<T, R>,
      ) => { case: (pattern: Pattern<T>, result: PatternResult<T, R>) => any; when: (guard: (value: T) => boolean, result: PatternResult<T, R>) => any; default: (result: PatternResult<T, R>) => { build: () => (value: T) => R; }; };
  }

  Create a pattern matcher with guards and nested patterns

  Example

  type User = {
    name: string
    age: number
    permissions: string[]
  }
  
  const canAccess = Match.builder<User, boolean>()
    .when(u => u.permissions.includes("admin"), true)
    .case({ age: n => n >= 18, permissions: p => p.length > 0 }, true)
    .default(false)
    .build()
  Copy

• exhaustive: <T extends string | number | symbol, R extends unknown>(
      cases: RequireExhaustive<T, Record<T, R>>,
  ) => (value: T) => R

  Create a type-safe exhaustive match for union types

  Example

  type Status = "pending" | "success" | "error"
  const status: Status = "success"
  const result = Match.exhaustive<Status, string>({
    pending: "Waiting...",
    success: "Done!",
    error: "Failed!"
  })(status)
  // result = "Done!"
  Copy

  Example

  // For function values, wrap in object to prevent execution
  type Operation = "add" | "subtract" | "multiply"
  const ops = Match.exhaustive<Operation, { fn: (a: number, b: number) => number }>({
    add: { fn: (a, b) => a + b },
    subtract: { fn: (a, b) => a - b },
    multiply: { fn: (a, b) => a * b }
  })
  const compute = ops("multiply").fn
  const result = compute(4, 5) // 20
  Copy

• partial: <T extends string | number | symbol, R extends unknown>(
      cases: Partial<Record<T, R | ((value: T) => R)>>,
  ) => {
      withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
  }

  Create a partial match that requires a default

  Example

  const httpCode = 404
  const message = Match.partial<number, string>({
    200: "OK",
    201: "Created",
    404: "Not Found",
    500: "Server Error"
  }).withDefault("Unknown Status")(httpCode)
  // message = "Not Found"
  Copy

  Example

  // With function default
  const getMessage = Match.partial<number, string>({
    0: "Zero",
    1: "One",
    2: "Two"
  }).withDefault((n) => `Number: ${n}`)
  getMessage(5) // "Number: 5"
  Copy

• struct: <T extends unknown, R extends unknown>() => {
      build: () => (value: T) => R;
      case: (
          pattern: Pattern<T>,
          handler: (value: T) => R,
      ) => { case: (pattern: Pattern<T>, handler: (value: T) => R) => any; build: () => (value: T) => R; };
  }

  Pattern matching for objects with specific structure

  Example

  type Event =
    | { type: "click"; x: number; y: number }
    | { type: "keypress"; key: string }
    | { type: "hover"; element: string }
  
  const handler = Match.struct<Event, void>()
    .case({ type: "click" }, (e) => console.log(`Click at ${e.x}, ${e.y}`))
    .case({ type: "keypress", key: "Enter" }, () => console.log("Enter pressed"))
    .case({ type: "hover" }, (e) => console.log(`Hovering over ${e.element}`))
    .build()
  Copy

• withGuards: <T extends unknown, R extends unknown>(
      guards: [(value: T) => boolean, R | ((value: T) => R)][],
  ) => {
      withDefault: (defaultValue: R | ((value: T) => R)) => (value: T) => R;
  }

  Pattern match with guards

  Example

  const score = 85
  const grade = Match.withGuards<number, string>([
    [n => n >= 90, "A"],
    [n => n >= 80, "B"],
    [n => n >= 70, "C"],
    [n => n >= 60, "D"]
  ]).withDefault("F")(score)
  // grade = "B"
  Copy

  Example

  // With function results for custom messages
  const age = 25
  const category = Match.withGuards<number, string>([
    [n => n < 13, n => `Child (${n} years)`],
    [n => n < 20, n => `Teenager (${n} years)`],
    [n => n < 60, n => `Adult (${n} years)`],
    [n => n >= 60, n => `Senior (${n} years)`]
  ]).withDefault("Unknown")(age)
  // category = "Adult (25 years)"
  Copy