Fluxo de controle conciso com if let

A sintaxe if let permite combinar ife let de uma forma menos prolixa para lidar com valores que correspondem a um padrão, enquanto ignora o resto. Considere o programa na Listagem 6-6 que corresponde a um valor Option<u8>, mas só deseja executar o código se o valor for 3.

fn main() {
    let algum_valor_u8 = Some(0u8);
    match algum_valor_u8 {
        Some(3) => println!("tres"),
        _ => (),
    }
}

Listagem 6-6: match que só se preocupa com a execução do código quando o valor for Some(3).

Queremos fazer algo com a correspondência Some(3), mas nada fazer com nenhum outro valor Some<u8> ou valor None. Para satisfazer a expressão match, temos que adicionar, _ => ()após o processamento, apenas uma variante, que é muito código clichê para adicionar.

Em vez disso, poderíamos escrever isso de forma mais curta usando if let. O código a seguir se comporta da mesma forma que o match da Listagem 6-6:

fn main() {
    let algum_valor_u8 = Some(0u8);
    if let Some(3) = algum_valor_u8 {
        println!("tres");
    }
}

A sintaxe if let assume um padrão e uma expressão separados por um sinal de igual. Funciona da mesma forma que match, onde a expressão é dada a match e o padrão é seu primeiro braço.

Usar if let significa menos digitação, menos indentação e menos código clichê. No entanto, você perde a verificação exaustiva que match impõe. A escolha entre match e if let depende do que você está fazendo em sua situação particular e se ganhar concisão é uma compensação apropriada para perder uma verificação exaustiva.

Em outras palavras, você pode pensar em if let como um açúcar de sintaxe para um match que executa o código quando o valor corresponde a um padrão e, em seguida, ignora todos os outros valores.

Podemos incluir um else com um if let. O bloco de código que acompanha o else é o mesmo que o bloco de código que acompanha o caso _ na expressão match que é equivalente a if let e else. Lembre-se da definição do enum Coin na Listagem 6-4, em que a variante Quarter também continha um valor UsState. Se quiséssemos contar todas as moedas que não são um quarto que vemos e, ao mesmo tempo, anunciar o estado dos quartos, poderíamos fazer isso com uma expressão match como esta:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --recorte--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    match coin {
        Coin::Quarter(state) => println!("quarter do Estado {:?}!", state),
        _ => count += 1,
    }
}

Ou podemos usar uma expressão if let e else assim:

#[derive(Debug)]
enum UsState {
    Alabama,
    Alaska,
    // --recorte--
}

enum Coin {
    Penny,
    Nickel,
    Dime,
    Quarter(UsState),
}

fn main() {
    let coin = Coin::Penny;
    let mut count = 0;
    if let Coin::Quarter(state) = coin {
        println!("quarter do Estado {:?}!", state);
    } else {
        count += 1;
    }
}

Se você tiver uma situação em que seu programa tenha uma lógica muito prolixa para ser expressa usando um match, lembre-se de que if let também está em sua caixa de ferramentas Rust.

Resumo

Agora cobrimos como usar enums para criar tipos personalizados que podem ser um de um conjunto de valores enumerados. Mostramos como o tipo Option<T> da biblioteca padrão ajuda você a usar o sistema de tipos para evitar erros. Quando os valores enum têm dados dentro deles, você pode usar match ou if let para extrair e usar esses valores, dependendo de quantos casos você precisa tratar.

Seus programas Rust agora podem expressar conceitos em seu domínio usando structs e enums. A criação de tipos personalizados para usar em sua API garante a segurança do tipo: o compilador fará com que suas funções obtenham apenas valores do tipo que cada função espera.

Para fornecer aos seus usuários uma API bem organizada, fácil de usar e que apenas exponha exatamente o que os usuários precisarão, vamos agora nos módulos do Rust.

Traduzido por Acervo Lima. O original pode ser acessado aqui.

Licença

• Apache License, Version 2.0
• MIT license

<< Anterior Próximo >>