Da trilha de Rust Este conceito ainda não saiu como card do dia. ir para o card de hoje

Rust Tipos Básico

Enums e match

Em Rust, enum é uma forma de definir um tipo que pode ser um entre vários valores possíveis. Diferente de outras linguagens, cada variante pode carregar dados próprios, como números, strings ou até outras estruturas. Isso permite modelar estados de forma segura e expressiva.

O match é a ferramenta principal para lidar com enums. Ele compara um valor com uma série de padrões e executa o código correspondente. O compilador exige que o match seja exaustivo, ou seja, todas as variantes possíveis devem ser tratadas, evitando esquecimentos.

Para casos em que apenas uma variante interessa, o if let oferece uma sintaxe mais concisa que um match completo. Ele executa um bloco apenas se o padrão casar, ignorando as demais possibilidades.

Padrões podem ser simples (como Variante) ou complexos (como Variante { campo, .. }), permitindo extrair e usar os dados internos de forma direta e segura.

Pontos-chave

  • enum define um tipo que pode assumir uma entre várias variantes, cada uma podendo ter dados associados.
  • O match é exaustivo: o compilador força o tratamento de todas as variantes.
  • if let é um atalho para quando apenas uma variante interessa, evitando um match completo.
  • Padrões podem desestruturar dados internos das variantes, como Mensagem::Mover { x, y }.
  • Use _ como curinga para ignorar valores que não importam no match.
enums_match.rs
// Exemplo de enum com dados e match exaustivo
enum Forma {
    Circulo(f64),
    Retangulo { largura: f64, altura: f64 },
}

fn area(forma: &Forma) -> f64 {
    match forma {
        Forma::Circulo(raio) => std::f64::consts::PI * raio * raio,
        Forma::Retangulo { largura, altura } => largura * altura,
    }
}

fn main() {
    let c = Forma::Circulo(2.0);
    let r = Forma::Retangulo { largura: 3.0, altura: 4.0 };

    println!("Área do círculo: {:.2}", area(&c));
    println!("Área do retângulo: {:.2}", area(&r));

    // if let: só interessa se for Círculo
    if let Forma::Circulo(raio) = c {
        println!("O círculo tem raio {}", raio);
    }
}

Exercícios

  1. 1
    Fácil

    Identificando variantes com match

    Crie um enum Cor com as variantes Vermelho, Verde e Azul. Depois, escreva uma função descrever(cor: &Cor) -> &str que retorne uma string descrevendo a cor. Use match para tratar todas as variantes.

    Resolver
  2. 2
    Médio

    Enum com dados e match com desestruturação

    Defina um enum Mensagem com as variantes Sair, Mover { x: i32, y: i32 } e Escrever(String). Implemente uma função processar(msg: &Mensagem) que imprima uma mensagem adequada para cada variante. Use match exaustivo.

    Resolver
  3. 3
    Desafio

    Processador de formas com if let e match

    Crie um enum Forma com as variantes Circulo(f64), Retangulo { largura: f64, altura: f64 } e Triangulo { base: f64, altura: f64 }. Implemente area(&self) -> f64 usando match. No main, crie um vetor de formas, calcule a área total e, usando if let, verifique se alguma forma é um círculo e imprima seu raio. Exiba a área total formatada com duas casas decimais.

    Resolver

Continue estudando