Início / coding / Perguntas / 79319498
Accepted
Harry
Asked: 2024-12-31 16:24:59 +0800 CST

Como passar um closure para ser executado antes que a variante Ok retorne valor

  • 772

Eu tenho uma função que retorna um Resulttipo. Dentro dessa função, outra função está sendo chamada, que retorna Resulto tipo. E, se o valor retornado for uma Errvariante, chame uma função/fechamento antes de borbulhar esse erro, senão, se for uma Okvariante, chame uma função/fechamento e então simplesmente retorne o valor contido. Isso é o que eu escrevi até agora

fn foo1() -> Result<i32, String> {
    Err("error".to_string())
}

fn foo2() -> Result<String, bool> {
    let res = foo1().map_err(|err| {
        println!("foo1 failed {}", err);
        false
    })?;

    // I know I can call some closure in here, but I want something like map_err which will call different closures depending on the Result variant
    Ok(res.to_string())
}

fn main() {
    foo2();
}
rust

2 respostas

  1. Best Answer

    Eu diria que você provavelmente chegou a um ponto em que suas necessidades são suficientemente especializadas para que você deva simplesmente implementar matcho que realmente precisa.

    Combinadores e funções de ordem superior existem para sinalizar caminhos e fornecer informações semânticas ao leitor, mas se eles não se aplicam diretamente ou não deixam as coisas mais claras, é perfeitamente aceitável e esperado que não sejam usados .

    Então podemos desaçucarar seu snippet para isto:

    fn foo1() -> Result<i32, String> {
    Err("error".to_string())
}

fn foo2() -> Result<String, bool> {
    match foo1() {
        Ok(res) => {
            println!("foo1 succeeded {}", res);
            Ok(res.to_string())
        }
        Err(err) => {
            println!("foo1 failed {}", err);
            Err(false)
        }
    }
}

fn main() {
    let res = foo2();
    match res {
        Ok(_) => println!("succeeded"),
        Err(_) => println!("failed")
    }
}

    e não acho que estamos em pior situação por isso. Na verdade, é bem o oposto: o uso de um raw matchna verdade sinaliza ao leitor (incluindo o seu futuro) que estamos realizando um conjunto não óbvio de transformações.

    • 5

  2. Acho que posso usar uma combinação de mapmétodos map_errcomo abaixo

    fn foo1() -> Result<i32, String> {
    Err("error".to_string())
}

fn foo2() -> Result<String, bool> {
    let res = {
        foo1()
        .map(|res| {
            println!("foo1 succeeded {}", res);
            res.to_string()
        })
        .map_err(|err| {
            println!("foo1 failed {}", err);
            false
        })?
    };
    
    Ok(res)
}

fn main() {
    let res = foo2();
    match res {
        Ok(_) => println!("succeeded"),
        Err(_) => println!("failed")
    }
}
    • 0

relate perguntas