Pattern matching with match and is

// run: Console.log(JSON.stringify([describe(new NotFound({ id: "7" })), describe(new Timeout()), describe(new Denied({ user: "Ada", reason: "admin" })), describe(new Denied({ user: "Ada", reason: "other" }))]))
errorclass NotFound NotFoundclass NotFound { id(property) id: string: string }
errorclass Timeout Timeoutclass Timeout
errorclass Denied Deniedclass Denied { user(property) user: string: string; reason(property) reason: string: string }

type Failuretype Failure = Denied | NotFound | Timeout = NotFoundclass NotFound | Timeoutclass Timeout | Deniedclass Denied

functionfunction describe(failure: Failure): string!! describefunction describe(failure: Failure): stringPlain JavaScript: VibeLang code calls it directly. TypeScript callers see Effect<string, never, never>.(failure(parameter) failure: Failure: Failuretype Failure = Denied | NotFound | Timeout) {
  return match (failure) {
    when NotFound and { let idlet id: string }: `no user ${idlet id: string}`;
    when Timeoutclass Timeout: "retry";
    when Denied and { reason: "root" or "admin" }: "denied by policy";
    when Deniedclass Denied: `denied ${failure(parameter) failure: Denied.user(property) user: string}`;
  }
}
// Output: ["no user 7","retry","denied by policy","denied Ada"]

// run: Console.log(retryDelay(new Timeout())); Console.log(retryDelay(new NotFound({ id: "7" })))
function retryDelayfunction retryDelay(failure: Failure): string!!(failure(parameter) failure: Failure: Failure(alias) type Failure = Denied | NotFound | Timeout) {
  return match (failure) {
    when Timeout(alias) class Timeout: do {
      Console(alias) module "effect/Console".logconst log: (...args: ReadonlyArray<any>) => void!!Runs here and returns void.Logs a general-purpose message to the console.("timed out")
      "1 second"
    };
    default: "0 millis";
  }
}
// Output: timed out
// Output: 1 second
// Output: 0 millis

// run: Console.log(JSON.stringify([shape([]), shape([2]), shape([2, 3, 4]), shape({ kind: "box", size: 5 }), shape({ kind: "point", size: 1 }), shape({ kind: "other" })]))
functionfunction shape(value: ReadonlyArray<number> | {
    readonly kind: string;
    readonly size?: number;
}): string!! shapefunction shape(value: ReadonlyArray<number> | { readonly kind: string; readonly size?: number; }): stringPlain JavaScript: VibeLang code calls it directly. TypeScript callers see Effect<string, never, never>.(value(parameter) value: readonly number[] | {
    readonly kind: string;
    readonly size?: number;
}: ReadonlyArrayinterface ReadonlyArray<T><number> | { kind(property) kind: string: string; size(property) size?: number | undefined?: number }) {
  return match (value) {
    when []: "empty";
    when [let onlylet only: any]: `one: ${onlylet only: any}`;
    when [let firstlet first: any, ...let restlet rest: any[]]: `${firstlet first: any} then ${restlet rest: any[].length(property) Array<any>.length: numberGets or sets the length of the array. This is a number one higher than the highest index in the array.} more`;
    when { kind: "box", let sizelet size: number | undefined }: `box of ${sizelet size: number | undefined}`;
    when { kind: "point", ...let otherslet others: Omit<{
    readonly kind: string;
    readonly size?: number;
}, "kind"> }: `point with ${Objectvar Object: ObjectConstructorProvides functionality common to all JavaScript objects..keys(method) ObjectConstructor.keys(o: {}): string[]Returns the names of the enumerable string properties and methods of an object.(otherslet others: Omit<{
    readonly kind: string;
    readonly size?: number;
}, "kind">).length(property) Array<string>.length: numberGets or sets the length of the array. This is a number one higher than the highest index in the array.} more keys`;
    default: "other";
  }
}
// Output: ["empty","one: 2","2 then 2 more","box of 5","point with 1 more keys","other"]

// run: Console.log(greeting(Option.some("Ada"))); Console.log(greeting(Option.none())); Console.log(report("ada")); Console.log(report("").includes("NotFound"))
functionfunction greeting(name: Option.Option<string>): string!! greetingfunction greeting(name: Option.Option<string>): stringPlain JavaScript: VibeLang code calls it directly. TypeScript callers see Effect<string, never, never>.(name(parameter) name: Option<string>: Option(alias) module "effect/Option".Optiontype Option<A> = None<A> | Some<A>The Option data type represents optional values. An Option<A> is either
Some<A>, containing a value of type A, or None, representing absence.<string>) {
  return match (name) {
    when Option.Some(let nlet n: string): `Hello, ${nlet n: string}`;
    when Option.None: "Hello";
  }
}

function reportfunction report(id: string): string!!(id(parameter) id: string: string) {
  const outcomeconst outcome: Exit<{
    readonly name: string;
}, NotFound> = exitconst exit: <{
    readonly name: string;
}, NotFound, never>(self: {
    readonly name: string;
}!NotFound!) => Exit<{
    readonly name: string;
}, NotFound>!!Runs here and returns Exit<{ readonly name: string; }, NotFound>.Transforms an effect to encapsulate both failure and success using the Exit
data type.(getUserfunction getUser(id: string): {
    readonly name: string;
}!NotFound!Passed by name to exit as a program: it runs when that program runs, not here, and returns { readonly name: string; }.(id(parameter) id: string))
  return match (outcome) {
    when Exit.Success(let userlet user: {
    readonly name: string;
}): userlet user: {
    readonly name: string;
}.name(property) name: string;
    when Exit.Failure(let causelet cause: Cause<NotFound>): Cause(alias) module "effect/Cause".prettyconst pretty: <NotFound>(cause: Cause<NotFound>) => stringFormats a Cause as a human-readable string for logging or debugging.(causelet cause: Cause<NotFound>);
  }
}

function getUserfunction getUser(id: string): {
    readonly name: string;
}!NotFound!(id(parameter) id: string: string): { name(property) name: string: string }!NotFound(alias) class NotFound {
  if (id(parameter) id: string === "") throw new NotFound(alias) constructor NotFound<{
    readonly id: string;
}>(args: {
    readonly id: string;
}): NotFound({ id(property) id: string })
  return { name(property) name: string: "Ada" }
}
// Output: Hello, Ada
// Output: Hello
// Output: Ada
// Output: true

// run: Console.log([parity(2), parity(3)].join(", "))
const Evenconst Even: {
    [customMatcher](subject: unknown): boolean;
} = {
  [customMatcherconst customMatcher: typeof customMatcherThe proposal's Symbol.customMatcher: a static method that decides whether
a subject matches. It returns a boolean for x is M, and false, true,
or the extracted values for an extractor pattern M(...).](subject(parameter) subject: unknown: unknown) {
    return typeof subject(parameter) subject: unknown === "number" && subject(parameter) subject: number % 2 === 0
  }
}

functionfunction parity(n: number): "even" | "odd"!! parityfunction parity(n: number): "even" | "odd"Plain JavaScript: VibeLang code calls it directly. TypeScript callers see Effect<"even" | "odd", never, never>.(n(parameter) n: number: number) {
  return match (n) {
    when Evenconst Even: {
    [customMatcher](subject: unknown): boolean;
}: "even";
    default: "odd";
  }
}
// Output: even, odd

// run: Console.log(JSON.stringify([classify({ status: "failed", attempts: 3 }), classify({ status: "failed", attempts: 1 }), classify({ status: "queued", attempts: 0 }), classify({ status: "done", attempts: 0 }), classify({ status: "cancelled", attempts: 0 })]))
functionfunction classify(job: {
    readonly status: string;
    readonly attempts: number;
}): "escalate" | "leave" | "retry" | "running"!! classifyfunction classify(job: { readonly status: string; readonly attempts: number; }): "escalate" | "leave" | "retry" | "running"Plain JavaScript: VibeLang code calls it directly. TypeScript callers see Effect<"escalate" | "leave" | "retry" | "running", never, never>.(job(parameter) job: {
    readonly status: string;
    readonly attempts: number;
}: { status(property) status: string: string; attempts(property) attempts: number: number }) {
  return match (job) {
    when { status: "failed", attempts: let nlet n: number } and if (n >= 3): "escalate";
    when { status: "failed" }: "retry";
    when { status: not ("done" or "cancelled") }: "running";
    default: "leave";
  }
}
// Output: ["escalate","retry","running","leave","leave"]

// run: Console.log(JSON.stringify([isRetryable(new Timeout()), isRetryable(new Denied({ user: "Ada", reason: "root" })), isRetryable(new NotFound({ id: "7" }))]))
functionfunction isRetryable(failure: Failure): boolean!! isRetryablefunction isRetryable(failure: Failure): booleanPlain JavaScript: VibeLang code calls it directly. TypeScript callers see Effect<boolean, never, never>.(failure(parameter) failure: Failure: Failure(alias) type Failure = Denied | NotFound | Timeout) {
  return failure is Timeout(alias) class Timeout or Denied
}
// Output: [true,true,false]

// run: Console.log(firstFailure("ada")); Console.log(firstFailure("").includes("NotFound"))
function firstFailurefunction firstFailure(id: string): string!!(id(parameter) id: string: string) {
  const outcomeconst outcome: Exit<{
    readonly name: string;
}, NotFound> = exitconst exit: <{
    readonly name: string;
}, NotFound, never>(self: {
    readonly name: string;
}!NotFound!) => Exit<{
    readonly name: string;
}, NotFound>!!Runs here and returns Exit<{ readonly name: string; }, NotFound>.Transforms an effect to encapsulate both failure and success using the Exit
data type.(getUser(alias) function getUser(id: string): {
    readonly name: string;
}!NotFound!Passed by name to exit as a program: it runs when that program runs, not here, and returns { readonly name: string; }.(id(parameter) id: string))
  if (outcome is Exit.Failure(let causelet cause: Cause<NotFound>) && Cause(alias) module "effect/Cause".hasFailsconst hasFails: <NotFound>(self: Cause<NotFound>) => booleanReturns true if the cause contains at least one Fail reason.(causelet cause: Cause<NotFound>)) {
    return Cause(alias) module "effect/Cause".prettyconst pretty: <NotFound>(cause: Cause<NotFound>) => stringFormats a Cause as a human-readable string for logging or debugging.(causelet cause: Cause<NotFound>)
  }
  return "ok"
}
// Output: ok
// Output: true

// expect-error: EK4701
type Phasetype Phase = "draft" | "published" | "review" = "draft" | "review" | "published"

functionfunction phaseLabel(phase: Phase): "Draft" | "Published"!! phaseLabelfunction phaseLabel(phase: Phase): "Draft" | "Published"Plain JavaScript: VibeLang code calls it directly. TypeScript callers see Effect<"Draft" | "Published", never, never>.(phase(parameter) phase: Phase: Phasetype Phase = "draft" | "published" | "review") {
  return match (phase) {
    when "draft": "Draft";
    when "published": "Published";
  }
}

error EK4701: This match does not handle every case of Phase: "review" is left.