Variable Cond

Type declaration

• • <T extends unknown>(): Cond<T>

  • Create a new conditional expression

    Type Parameters

    • T extends unknown

    Returns Cond<T>

    Example

    const message = Cond<string>()
      .when(isError, "Error occurred")
      .when(isWarning, "Warning")
      .else("All good")
    Copy

• lazy: <T extends unknown>() => LazyCondChain<T>

  Create a lazy conditional that defers evaluation

  Example

  // Only evaluates conditions and values when needed
  const getMessage = Cond.lazy<string>()
    .when(() => isError(), () => computeErrorMessage())
    .when(() => isWarning(), () => computeWarningMessage())
    .else(() => "Success")
  Copy

  Example

  // Complex conditional with expensive checks
  const result = Cond.lazy<Action>()
    .when(
      () => user.role === "admin" && checkAdminPermissions(),
      () => ({ type: "admin", permissions: loadAdminPermissions() })
    )
    .when(
      () => user.role === "user" && user.isActive,
      () => ({ type: "user", permissions: loadUserPermissions() })
    )
    .else(() => ({ type: "guest", permissions: [] }))
  Copy

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

  Pattern matching helper that ensures exhaustiveness

  Example

  type Status = "pending" | "success" | "error"
  const status: Status = "success"
  const result = Cond.match(status)({
    "pending": "Waiting...",
    "success": "Done!",
    "error": "Failed!"
  })
  // result = "Done!"
  Copy

  Example

  // With function values
  const action = "compute"
  const result = Cond.match(action)({
    "compute": () => expensiveComputation(),
    "cache": () => getCachedValue(),
    "skip": () => defaultValue
  })
  Copy

• of: <T extends unknown>() => Cond<T>

  Create a conditional expression that must end with else

  Example

  const x = 7
  const result = Cond.of<string>()
    .when(x > 10, "large")
    .elseWhen(x > 5, "medium")
    .else("small")
  // result = "medium"
  Copy

  Example

  // With lazy evaluation
  const discount = Cond.of<number>()
    .when(isPremium, () => calculatePremiumDiscount())
    .when(isLoyal, () => calculateLoyaltyDiscount())
    .else(0)
  Copy