Skip to content

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.

tyrus
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"); }.

tyrus
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 ​

tyrus
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.

tyrus
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.

tyrus
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.

tyrus
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.

tyrus
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.53975

Patrón Wildcard ​

Usa _ para coincidir con cualquier valor que no fue coincidido por arms anteriores.

tyrus
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.

tyrus
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 odd

Destructuring de Objeto ​

Desestructura objetos y coincide con valores específicos de campos.

tyrus
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.

tyrus
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.

tyrus
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.0

Exhaustividad ​

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.