< 返回版块

shanliu 发表于 2022-05-07 10:32

有没可以改善多层嵌套的写法?

struct A{}
fn main() {
    let avar:Result<A, A>=Result::Ok(A{});
    match avar {
        Ok(a)=>{
            let bvar:Result<A, A>=Result::Ok(A{});
            match bvar {
                Ok(a)=>{
                    let cvar:Result<A, A>=Result::Ok(A{});
                    match cvar {
                        Ok(a)=>{
                            //xxx
                        }
                        Err(a)=>{
                             //错误返回
                        }
                    }
                }
                Err(a)=>{
                    //错误返回
                }
            }
        }
        Err(a)=>{
            //错误返回
        }
    }
}

评论区

写评论
苦瓜小仔 2022-05-08 00:02
#![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
作者 shanliu 2022-05-07 23:34

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

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

--
👇
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)
}

作者 shanliu 2022-05-07 23:33

没有具体的需求

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

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

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

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

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

Aya0wind 2022-05-07 22:07

也许你要的是这种?

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)
}

Bai-Jinlin 2022-05-07 19:19

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

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

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

Marco 2022-05-07 17:06
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;
    }
}
作者 shanliu 2022-05-07 16:36

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

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

作者 shanliu 2022-05-07 16:31

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

👇
Pikachu: 简单的建议:

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

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

作者 shanliu 2022-05-07 16:29

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!(),
    }
}
Pikachu 2022-05-07 14:29

简单的建议:

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

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

PrivateRookie 2022-05-07 13:12

看不太懂你这段代码想干什么, 但 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!(),
    }
}
Bai-Jinlin 2022-05-07 13:00

这不就是?吗?

作者 shanliu 2022-05-07 11:37

不是语法糖?的问题

--
👇
Grobycn: ? 语法糖

Grobycn 2022-05-07 11:10

? 语法糖

1 共 14 条评论, 1 页