Rust 1.22

Question

我有一些看起来像这样的代码：

f(a).and_then(|b| {
    g(b).and_then(|c| {
        h(c).map(|d| {
            do_something_with(a, b, c, d)
        })
    })
})

f，g和h返回Option值的位置。我需要在a计算中使用所有中间值（b，c，d和do_something_with）。压痕非常深。有一个更好的方法吗？理想情况下它看起来像这样（当然这不起作用）：

try {
    let b = f(a);
    let c = g(b);
    let d = h(c);
    do_something_with(a, b, c, d)
} rescue NonexistentValueException {
    None
}

Answer 1

Rust 1.22

question mark operator现在支持Option，因此您可以将您的功能编写为

fn do_something(a: i32) -> Option<i32> {
    let b = f(a)?;
    let c = g(b)?;
    let d = h(c)?;
    do_something_with(a, b, c, d) // wrap in Some(...) if this doesn't return an Option
}

Rust 1.0

Rust标准库定义了一个try!宏（以及等同于?运算符，从Rust 1.13开始），它解决了Result的这个问题。宏看起来像这样：

macro_rules! try {
    ($expr:expr) => (match $expr {
        $crate::result::Result::Ok(val) => val,
        $crate::result::Result::Err(err) => {
            return $crate::result::Result::Err($crate::convert::From::from(err))
        }
    })
}

如果参数为Err，则从具有该Err值的函数返回。否则，它将计算为Ok中包含的值。宏只能在返回Result的函数中使用，因为它返回它遇到的错误。

我们可以为Option制作类似的宏：

macro_rules! try_opt {
    ($expr:expr) => (match $expr {
        ::std::option::Option::Some(val) => val,
        ::std::option::Option::None => return None
    })
}

然后您可以像这样使用此宏：

fn do_something(a: i32) -> Option<i32> {
    let b = try_opt!(f(a));
    let c = try_opt!(g(b));
    let d = try_opt!(h(c));
    do_something_with(a, b, c, d) // wrap in Some(...) if this doesn't return an Option
}

Answer 2

受到try! for Result概念的启发，如果monad降为None，让我们将自己的宏包装到范围的早期返回。

macro_rules! get(
    ($e:expr) => (match $e { Some(e) => e, None => return None })
);

（从this reddit thread被盗）

现在您可以线性运行代码：

fn blah() -> Option<...> { // ... is the return type of do_something_with()
    let a = 123;
    let b = get!(f(a));
    let c = get!(g(b));
    let d = get!(h(c));
    do_something_with(a, b, c, d)
}

（runnable gist）

是否有一种非混乱的方式来链接返回Option值的函数的结果？

2 个答案:

Rust 1.22

Rust 1.0