Pattern Matching
match es una forma nativa de flujo de control de tyrus. El checker garantiza que todos los patrones estén cubiertos o exista un caso predeterminado.
Los arms usan directamente pattern => body. Para una única expresión devuelta, usa la forma compacta pattern => expression;; el punto y coma es obligatorio. Los arms con bloque siguen siendo compatibles y su punto y coma final es opcional. Los paréntesis alrededor de un patrón son opcionales para todos los patrones soportados, por lo que "ready" => y ("ready") => son equivalentes.
function label(score: i32): string {
match (score) {
90..=100 => "A";
_ => { return "F"; }
}
}Un arm compacto es un return
pattern => expression; devuelve expression desde la función que lo contiene, exactamente como return expression;. Por eso, dentro de un bucle, sale de la función entera, no solo del bucle, y nada después del match se ejecuta. El programa de abajo imprime solo one. Para ejecutar el arm y continuar, usa un arm con bloque, 1 => { print("one"); }.
const main = (): void => {
const codes: i32[] = [1, 2, 3];
for (const code of codes) {
match (code) {
1 => print("one"); // returns from `main`
_ => { print("other"); } // continues after the `match`
}
print("next");
}
print("done");
};Match en Unions
type Result =
| { tag: "success"; data: string }
| { tag: "error"; code: i32; message: string };
const res: Result = { tag: "error", code: 404, message: "Not Found" };
match (res) {
{ tag: "success", data } => {
print(`Data: ${data}`); // "Data: ..."
}
({ tag: "error", code, message }) if (code === 404) => {
print(`Error specific 404: ${message}`); // "Error specific 404: Not Found"
}
{ tag: "error", message } => {
print(`Other error: ${message}`); // "Other error: ..."
}
_ => {
print("Unknown result");
}
}Los patrones soportados incluyen matches de literal, wildcard _, bindings de captura, arms con guard, destructuring de objeto con match de campo literal y patrones de array.
Patrones de Array
Los patrones de array desestructuran valores Array<T> y readonly Array<T>. [] coincide solo con un array vacío, [first, second] coincide exactamente con dos elementos y [head, ...tail] coincide con uno o más elementos. Los bindings de elementos tienen tipo T; tail es un nuevo Array<T> con propiedad de los elementos restantes, equivalente a values.slice(1), y no una vista prestada. Un patrón de array permite como máximo un patrón de resto, debe ser final y debe ser un binding o _. Los elementos literales deben ser asignables a T. Los patrones de array anidados y la exhaustividad por longitud aún no están disponibles porque los arrays ordinarios no llevan la longitud en el tipo.
function inspect(values: i32[]): void {
match (values) {
[] => { print("empty"); }
[value] => { print(value); }
[head, ...tail] => { print(head, tail.length); }
}
}Match de Literal
Compara directamente contra valores constantes como strings, números o booleanos.
const day: string = "Monday";
match (day) {
("Saturday" | "Sunday") => {
print("Weekend");
}
("Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday") => {
print("Weekday");
}
_ => {
print("Invalid day");
}
}
// "Weekday"Patrones de Range
Compara un valor numérico o char contra un intervalo acotado: a..b excluye b, a..=b lo incluye, y cualquiera de los límites puede omitirse para un range abierto (..b, a..). Un límite del range debe ser asignable al propio tipo del sujeto, comparar un string contra un range numérico es un error de compilación.
const main = (): void => {
const getLetterGrade = (score: u8): string => {
match (score) {
90..=100 => "A";
80..=89 => "B";
70..=79 => "C";
60..=69 => "D";
0..=59 => "F";
_ => "Invalid Score";
}
};
print(getLetterGrade(95)); // A
print(getLetterGrade(80)); // B
print(getLetterGrade(79)); // C
print(getLetterGrade(61)); // D
print(getLetterGrade(59)); // F
print(getLetterGrade(150)); // Invalid Score
};Un range vacío o invertido (10..5) es un warning, no un error, simplemente nunca coincide, igual que cualquier otro arm inalcanzable. Detectar arms superpuestos y verificar la exhaustividad para un tipo numérico finito (u8, por ejemplo) son decisiones deliberadas de alcance, no vacíos: ambos siguen abiertos, como refinamientos rastreados, no comportamiento obligatorio.
Patrones de Binding
Captura valores coincidentes en variables para usar en el cuerpo del arm.
type Shape =
| { kind: "circle"; radius: f64 }
| { kind: "rectangle"; width: f64; height: f64 };
const area = (shape: Shape): f64 => {
match (shape) {
({ kind: "circle", radius }) => {
return 3.14159 * radius * radius;
}
({ kind: "rectangle", width, height }) => {
return width * height;
}
}
};
const circle: Shape = { kind: "circle", radius: 5.0 };
print(area(circle)); // 78.53975Patrón Wildcard
Usa _ para coincidir con cualquier valor que no fue coincidido por arms anteriores.
const status: i32 = 200;
match (status) {
(200) => {
print("OK");
}
404 => {
print("Not Found");
}
(500) => {
print("Server Error");
}
_ => {
print(`Other status: ${status}`);
}
}
// "OK"Arms con Guard
Agrega condiciones if en arms para coincidencia más específica.
const value: i32 = 15;
match (value) {
(v) if (v < 0) => {
print("Negative");
}
0 => {
print("Zero");
}
(v) if (v % 2 === 0) => {
print("Positive even");
}
_ => {
print("Positive odd");
}
}
// Positive oddDestructuring de Objeto
Desestructura objetos y coincide con valores específicos de campos.
interface Point {
x: f64;
y: f64;
}
const describe = (point: Point): string => {
match (point) {
({ x: 0, y: 0 }) => {
return "Origin";
}
({ x: 0, y }) => {
return `On Y-axis at ${y}`;
}
({ x, y: 0 }) => {
return `On X-axis at ${x}`;
}
({ x, y }) => {
return `Point at (${x}, ${y})`;
}
}
};
print(describe({ x: 0, y: 5 })); // "On Y-axis at 5"
print(describe({ x: 3, y: 0 })); // "On X-axis at 3"
print(describe({ x: 1, y: 2 })); // "Point at (1, 2)"Patrones Combinados
Combina narrowing de tipo, guards y match de literal para lógica compleja.
type Input =
| string
| number
| boolean;
const process = (input: Input): string => {
match (input) {
(s: string) if (s.length === 0) => {
return "Empty string";
}
(s: string) => {
return `String: ${s}`;
}
(n: number) if (n < 0) => {
return "Negative number";
}
(n: number) if (n === 0) => {
return "Zero";
}
(n: number) => {
return `Positive number: ${n}`;
}
(true) => {
return "Boolean true";
}
(false) => {
return "Boolean false";
}
}
};
print(process("hello")); // "String: hello"
print(process("")); // "Empty string"
print(process(-5)); // "Negative number"
print(process(0)); // "Zero"
print(process(42)); // "Positive number: 42"
print(process(true)); // "Boolean true"Patrones de Variante de Enum
Haz match de un enum algebraico por variante y liga un nombre por cada campo del payload. Una variante con dos campos exige dos bindings: un único nombre para un payload de varios campos se rechaza, porque no hay forma de leer los campos de vuelta a partir de él. Una variante sin payload no acepta ningún binding.
import { PI } from "tyrus:math";
enum Shape {
Circle(f64),
Rect(f64, f64),
Empty,
}
const area = (shape: Shape): f64 => {
match (shape) {
Shape.Circle(r) => PI * r * r;
Shape.Rect(w, h) => w * h;
Shape.Empty => 0.0;
}
};
print(area(Shape.Circle(2.0))); // 12.566370614359172
print(`${area(Shape.Circle(2.0)):.2f}`); // 12.57
print(area(Shape.Rect(3.0, 4.0))); // 12.0
print(area(Shape.Empty)); // 0.0Exhaustividad
Para subjects cerrados como enum, boolean, literal union y tagged union, match debe cubrir toda variante o incluir _. Arms inalcanzables se reportan como warnings.
Switch está documentado en Flujo de control
Usa switch para dispatch literal sobre valores primitivos. Usa match cuando importan destructuring, narrowing o exhaustividad.
