Skip to content

Pattern Matching ​

match é uma forma nativa de fluxo de controle do tyrus. O checker garante que todos os padrões sejam cobertos ou que exista um caso padrão.

Arms usam diretamente pattern => body. Para uma única expressão retornada, use a forma compacta pattern => expression;; o ponto e vírgula é obrigatório. Arms com bloco continuam suportadas, e seu ponto e vírgula final é opcional. Parênteses ao redor de um padrão são opcionais para todos os padrões suportados, portanto "ready" => e ("ready") => são equivalentes.

tyrus
function label(score: i32): string {
    match (score) {
        90..=100 => "A";
        _ => { return "F"; }
    }
}

Um arm compacto é um return

pattern => expression; retorna expression da função que o contém, exatamente como return expression;. Por isso, dentro de um laço, ele sai da função inteira, não só do laço, e nada depois do match executa. O programa abaixo imprime apenas one. Para executar o arm e continuar, use um arm com bloco, 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 em 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");
    }
}

Padrões suportados incluem matches de literal, wildcard _, bindings de captura, arms com guard, destructuring de objeto com match de campo literal e padrões de array.

Padrões de Array ​

Padrões de array desestruturam valores Array<T> e readonly Array<T>. [] corresponde somente a um array vazio, [first, second] corresponde exatamente a dois elementos e [head, ...tail] corresponde a um ou mais elementos. Bindings de elementos têm tipo T; tail é um novo Array<T> com posse dos elementos restantes, equivalente a values.slice(1), e não uma view emprestada. Um padrão de array permite no máximo um padrão de resto, ele deve estar no fim e deve ser um binding ou _. Elementos literais devem ser atribuíveis a T. Padrões de array aninhados e exaustividade por comprimento ainda não estão disponíveis porque arrays comuns não carregam o comprimento no tipo.

tyrus
function inspect(values: i32[]): void {
    match (values) {
        [] => { print("empty"); }
        [value] => { print(value); }
        [head, ...tail] => { print(head, tail.length); }
    }
}

Match de Literal ​

Compare diretamente contra valores constantes como strings, números ou booleanos.

tyrus
const day: string = "Monday";

match (day) {
    ("Saturday" | "Sunday") => {
        print("Weekend");
    }
    ("Monday" | "Tuesday" | "Wednesday" | "Thursday" | "Friday") => {
        print("Weekday");
    }
    _ => {
        print("Invalid day");
    }
}
// "Weekday"

Padrões de Range ​

Compare um valor numérico ou char contra um intervalo limitado: a..b exclui b, a..=b inclui, e qualquer um dos limites pode ser omitido para um range aberto (..b, a..). Um limite do range deve ser atribuível ao próprio tipo do sujeito, comparar uma string contra um range numérico é erro de compilação.

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
};

Um range vazio ou invertido (10..5) é um warning, não um erro, ele simplesmente nunca dá match, igual a qualquer outra arm inalcançável. Detectar arms sobrepostas e verificar exaustividade para um tipo numérico finito (u8, por exemplo) são decisões deliberadas de escopo, não lacunas: os dois continuam em aberto, como refinamentos rastreados, não comportamento obrigatório.

Padrões de Binding ​

Capture valores correspondidos em variáveis para usar no corpo da 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

Padrão Wildcard ​

Use _ para corresponder a qualquer valor que não foi correspondido 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 com Guard ​

Adicione condições if em arms para correspondência mais 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 ​

Desestruture objetos e corresponda a 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)"

Padrões Combinados ​

Combine narrowing de tipo, guards e match de literal para lógica complexa.

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"

Padrões de Variante de Enum ​

Faça match de um enum algébrico por variante e ligue um nome para cada campo do payload. Uma variante com dois campos exige dois bindings: um único nome para um payload de vários campos é recusado, pois não há como ler os campos de volta a partir dele. Uma variante sem payload não aceita binding algum.

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

Exaustividade ​

Para subjects fechados como enum, boolean, literal union e tagged union, match deve cobrir toda variante ou incluir _. Arms inalcançáveis são reportados como warnings.

Switch está documentado em Fluxo de controle

Use switch para dispatch literal sobre valores primitivos. Use match quando destructuring, narrowing ou exaustividade importam.