Início / coding / Perguntas / 76921767
Accepted
Rick de Water
Asked: 2023-08-17 20:58:04 +0800 CST

Como forçar o tipo de retorno de uma correspondência para ()?

  • 772

No exemplo simplificado a seguir, o compilador reclama que uma ramificação da matchinstrução retorna bool, enquanto a outra retorna ().

use std::collections::{HashMap, HashSet};

fn main() {
    let available = HashMap::from_iter([(2, "b"), (3, "c"), (4, "d")]);
    let mut set = HashSet::new();
    
    for i in [1, 2, 3, 4, 5] {
        match available.get(&i) {
            Some(s) => set.insert(*s),
            None => ()
        }
    }
}

No entanto, isso resulta em um erro:

error[E0308]: `match` arms have incompatible types
  --> src/main.rs:10:21
   |
8  | /         match available.get(&i) {
9  | |             Some(s) => set.insert(*s),
   | |                        -------------- this is found to be of type `bool`
10 | |             None => ()
   | |                     ^^ expected `bool`, found `()`
11 | |         }
   | |_________- `match` arms have incompatible types

Como posso informar ao compilador que a instrução match deve retornar ()e que o boolretornado de insertdeve ser ignorado?

rust

3 respostas

  1. Best Answer

    A maneira usual seria apenas colocar o braço em um bloco e cobri-lo com um ;, pois isso suprime o resultado da expressão:

    use std::collections::{HashMap, HashSet};

fn main() {
    let available = HashMap::from_iter([(2, "b"), (3, "c"), (4, "d")]);
    let mut set = HashSet::new();
    
    for i in [1, 2, 3, 4, 5] {
        match available.get(&i) {
            Some(s) => {
                set.insert(*s);
            }
            None => (),
        }
    }
}

    Uma alternativa provavelmente menos comum seria alimentar o valor para uma função "convertendo-a" em um ()exemplodrop

    use std::collections::{HashMap, HashSet};

fn main() {
    let available = HashMap::from_iter([(2, "b"), (3, "c"), (4, "d")]);
    let mut set = HashSet::new();
    
    for i in [1, 2, 3, 4, 5] {
        match available.get(&i) {
            Some(s) => drop(set.insert(*s)),
            None => (),
        }
    }
}

    Como alternativa, você pode simplesmente ignorar totalmente a segunda ramificação:

    use std::collections::{HashMap, HashSet};

fn main() {
    let available = HashMap::from_iter([(2, "b"), (3, "c"), (4, "d")]);
    let mut set = HashSet::new();
    
    for i in [1, 2, 3, 4, 5] {
        if let Some(s) = available.get(&i) {
            set.insert(*s);
        }
    }
}

    ou use uma função de ordem superior para esse efeito colateral, que embora não seja o mais comum, é uma coisa:

    use std::collections::{HashMap, HashSet};

fn main() {
    let available = HashMap::from_iter([(2, "b"), (3, "c"), (4, "d")]);
    let mut set = HashSet::new();
    
    for i in [1, 2, 3, 4, 5] {
        available.get(&i).map(|&s| set.insert(s));
    }
}
    • 10

  2. Você pode transformar ambos os blocos em declarações:

    match available.get(&i) {
    Some(s) => {
        set.insert(*s);
    }
    None => {}
}

    Ou você pode converter o matchpara um if- let:

    if let Some(&s) = available.get(&i) {
    set.insert(s);
}
    • 5

  3. Ainda outra opção é explorar que Optioné iterável e &stré Copy, então você pode passar a opção retornada por available.get()para Extend::extend():

    use std::collections::{HashMap, HashSet};

fn main() {
    let available = HashMap::<i32, &str>::from_iter([(2, "b"), (3, "c"), (4, "d")]);
    let mut set = HashSet::<&str>::new();
    
    for i in [1, 2, 3, 4, 5] {
        set.extend(available.get(&i));
    }
}

    Observe que isso requer anotações de tipo adicionais neste caso específico.

    O loop for pode ser reescrito em estilo funcional como

    set.extend([1, 2, 3, 4, 5].iter().map(|i| available.get(i)).flatten());
    • 1

relate perguntas