#![feature(let_chains)]
#![allow(unused)]
#![allow(clippy::eq_op)]
#![allow(clippy::nonminimal_bool)]

struct A {}

fn main() {
    const AVAR: Result<A, A> = Ok(A {});
    const ERR: Result<A, A> = Err(A {});
    if let Ok(a) = AVAR && let Ok(b) = {println!("Run"); ERR} && let Ok(c) = {println!("Not Run"); AVAR} { //
        println!("ok");
    } else {
        println!("err");
    }
}

// Run
// err

有引用+生命周期参数的时候，

引入闭包只会带来更多的问题

--
👇
Aya0wind: 也许你要的是这种？

struct A;
struct E;

fn use_a(a: A) -> Result<A, E> {
    Result::Ok(A)
}
fn use_b(b: A) -> Result<A, E> {
    Result::Ok(A)
}
fn use_c(c: A) -> Result<A, E> {
    Result::Err(E)
}

fn process() -> Result<A, E> {
    let avar: Result<A, E> = Result::Ok(A); //create A
    avar
        .and_then(use_a)
        .and_then(use_b)
        .and_then(use_c)
}

没有具体的需求

就是在想 match的多层嵌套 有没办法转成的 更好的多个平级if 使代码更好读的问题 好比

if let Err(ref e)=res{
}
if let Ok(ref e)=res{
}

--
👇
Bai-Jinlin: 那你倒是把条件说明白再提问题呀？？？你就放个代码我们说了问号明明可以解决后你就开始以我其实是是要这样那样的条件开始补充你的要求了，别的不说你起码把你为什么不用问号，和想要实现什么功能说出来吧？

--
👇
shanliu: 你大概想说的是 .map_err() 后? 放到闭包里比match代码更丑 而且闭包里放不了async

👇
Bai-Jinlin: 这不就是?吗？

也许你要的是这种？

struct A;
struct E;

fn use_a(a: A) -> Result<A, E> {
    Result::Ok(A)
}
fn use_b(b: A) -> Result<A, E> {
    Result::Ok(A)
}
fn use_c(c: A) -> Result<A, E> {
    Result::Err(E)
}

fn process() -> Result<A, E> {
    let avar: Result<A, E> = Result::Ok(A); //create A
    avar
        .and_then(use_a)
        .and_then(use_b)
        .and_then(use_c)
}

那你倒是把条件说明白再提问题呀？？？你就放个代码我们说了问号明明可以解决后你就开始以我其实是是要这样那样的条件开始补充你的要求了，别的不说你起码把你为什么不用问号，和想要实现什么功能说出来吧？

--
👇
shanliu: 你大概想说的是 .map_err() 后? 放到闭包里比match代码更丑 而且闭包里放不了async

👇
Bai-Jinlin: 这不就是?吗？

struct A{}
fn main() {
    let avar:Result<A, A>=Result::Ok(A{});
    if avar.is_err(){
        //错误返回
        return;
    }
    let bvar:Result<A, A>=Result::Ok(A{});
    if bvar.is_err(){
        //错误返回
        return;
    }
    let cvar:Result<A, A>=Result::Ok(A{});
    if cvar.is_err(){
        //错误返回
        return;
    }
}

你大概想说的是 .map_err() 后? 放到闭包里比match代码更丑 而且闭包里放不了async

👇
Bai-Jinlin: 这不就是?吗？

不放到闭包 放闭包复杂的类型出现诡异问题很难定位 已在用 clippy

👇
Pikachu: 简单的建议：

• 用clippy检查一遍你的代码，先看看clippy推荐的重构。
• 然后再放到vscode里面，看看rust-analyzer有没有什么建议。 一般来讲，这两个工具的建议是一致的。比如对于问题中的代码，它可能会提示用if let替换match。

当然，个人习惯上，我会选择用and_then、or_else来写这段代码。具体请参考Result文档。

avar 成功 => bvar 成功=>cvar

但不想太多层级 层级深了不好定位问题

--
👇
PrivateRookie: 看不太懂你这段代码想干什么, 但 match 是可以匹配元组的

struct A {}
fn main() {
   let avar: Result<A, A> = Result::Ok(A {});
   let bvar: Result<A, A> = Result::Ok(A {});
   let cvar: Result<A, A> = Result::Ok(A {});
   match (avar, bvar, cvar) {
        (Ok(a), Ok(b), Ok(c)) => todo!(),
        (Ok(_), Ok(_), Err(_)) => todo!(),
        (Ok(_), Err(_), Ok(_)) => todo!(),
        (Ok(_), Err(_), Err(_)) => todo!(),
        (Err(_), Ok(_), Ok(_)) => todo!(),
        (Err(_), Ok(_), Err(_)) => todo!(),
        (Err(_), Err(_), Ok(_)) => todo!(),
        (Err(_), Err(_), Err(_)) => todo!(),
    }
}

简单的建议：

• 用clippy检查一遍你的代码，先看看clippy推荐的重构。
• 然后再放到vscode里面，看看rust-analyzer有没有什么建议。 一般来讲，这两个工具的建议是一致的。比如对于问题中的代码，它可能会提示用if let替换match。

当然，个人习惯上，我会选择用and_then、or_else来写这段代码。具体请参考Result文档。

看不太懂你这段代码想干什么, 但 match 是可以匹配元组的

struct A {}
fn main() {
   let avar: Result<A, A> = Result::Ok(A {});
   let bvar: Result<A, A> = Result::Ok(A {});
   let cvar: Result<A, A> = Result::Ok(A {});
   match (avar, bvar, cvar) {
        (Ok(a), Ok(b), Ok(c)) => todo!(),
        (Ok(_), Ok(_), Err(_)) => todo!(),
        (Ok(_), Err(_), Ok(_)) => todo!(),
        (Ok(_), Err(_), Err(_)) => todo!(),
        (Err(_), Ok(_), Ok(_)) => todo!(),
        (Err(_), Ok(_), Err(_)) => todo!(),
        (Err(_), Err(_), Ok(_)) => todo!(),
        (Err(_), Err(_), Err(_)) => todo!(),
    }
}

这不就是?吗？

不是语法糖?的问题

--
👇
Grobycn: ? 语法糖

? 语法糖