match | Rust

• match | Rust

---

match no Rust

match é a estrutura de pattern matching do Rust. Ela serve para comparar um valor contra vários padrões e executar o bloco correspondente.

Além disso, em Rust o match é uma expressão, ou seja, ele pode retornar um valor e ser usado em atribuições, parâmetros e retornos de função.

Sintaxe básica

fn main() {
    let number = 2;

    match number {
        1 => println!("um"),
        2 => println!("dois"),
        3 => println!("três"),
        _ => println!("outro valor"),
    }
}

Como pensar no match

Cada “braço” do match tem este formato:

padrao => resultado

Exemplo:

let message = match number {
    1 => "um",
    2 => "dois",
    _ => "outro",
};

println!("{message}");

Aqui o match retorna uma &str.

---

Principal vantagem

O match funciona muito bem com enum, especialmente Option e Result. O livro oficial destaca que combinar match com enums é um padrão muito comum no Rust.

Exemplo com Option:

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(i) => Some(i + 1),
        None => None,
    }
}

---

O match precisa ser exaustivo

Esse é um dos pontos mais importantes: o Rust exige que o match cubra todas as possibilidades.

Exemplo inválido:

fn plus_one(x: Option<i32>) -> Option<i32> {
    match x {
        Some(i) => Some(i + 1),
    }
}

Isso não compila porque faltou tratar o caso None. O livro oficial explica exatamente esse ponto: em Rust, os matches são exaustivos.

---

O _ no match

Quando você não quer listar todos os casos manualmente, usa _ como coringa:

let value = 10;

match value {
    1 => println!("um"),
    2 => println!("dois"),
    _ => println!("qualquer outro"),
}

O _ significa “qualquer valor que não bateu antes”.

---

Capturando valores

Você também pode capturar o valor que caiu naquele braço:

let number = 8;

match number {
    0 => println!("zero"),
    n => println!("o valor é {n}"),
}

Aqui n recebe o valor que foi casado pelo padrão. O livro Programming Rust mostra esse uso com inteiros e explica que esse padrão funciona como um “catch-all” com variável.

---

match com enum

enum Direction {
    Left,
    Right,
    Up,
    Down,
}

fn main() {
    let dir = Direction::Left;

    match dir {
        Direction::Left => println!("esquerda"),
        Direction::Right => println!("direita"),
        Direction::Up => println!("cima"),
        Direction::Down => println!("baixo"),
    }
}

Esse é um uso extremamente idiomático em Rust.

---

Quando usar if let no lugar de match

Se você só se importa com um caso e quer ignorar o resto, if let costuma ficar mais curto.

let value = Some(3);

if let Some(x) = value {
    println!("valor: {x}");
}

O próprio livro oficial comenta que o match pode ficar verboso quando você quer tratar só um padrão, e aí if let é uma alternativa mais concisa.

---

Resumo

Use match quando você quiser:

• comparar um valor com vários padrões
• tratar enum, Option e Result
• garantir que todos os casos foram cobertos
• retornar um valor de forma elegante

Regra prática

• match: quando há vários casos relevantes
• if let: quando só um caso importa

---