在 Rust 中，处理多个 `Option<T>` 的惯用方式是什么？

Question

由于我对Rust还比较新，所以需要指导如何按惯例处理错误。我觉得处理错误的样板代码非常烦人。

我被多个Option<T>困扰。手动处理每种None情况太冗长。

例如，在Haskell中，您可以使用各种运算符（例如fmap、<*>、>>=）链接可选值（Maybe）操作：

f x = x * x
g x = x ++ x
main = print $ g <$> show <$> f <$> Just 2

在 Rust 中这似乎是不可能的。我正在尝试将一个由两个字符组成的牌字符串解析为一个结构体 Card：

const FACES: &'static str = "23456789TJQKA";
const SUITS: &'static str = "CDHS";
enum Face { /* ... */ }
enum Suit { C, D, H, S }
struct Card {
    face: Face,
    suit: Suit
}
impl FromStr for Card {
    type Err = ();
    fn from_str(x: &str) -> Result<Self, Self::Err> {
        let mut xs = x.chars();
        let a = chain(xs.next(), |x| FACES.find(x), Face::from_usize);
        let b = chain(xs.next(), |x| SUITS.find(x), Suit::from_usize);
        if let (Some(face), Some(suit)) = (a, b) {
            Ok(Card::new(face, suit))
        } else {
            Err(())
        }
    }
}

这段代码在Haskell中的写法如下：

import Data.List (elemIndex)
x = Just 'C'
suits = "CDHS"
data Suit = C | D | H | S deriving Show
fromInt 0 = C
find = flip elemIndex
main = print $ x >>= find suits >>= return . fromInt

由于 Haskell 通过 >>= 进行链接，使得操作单子的内部值成为可能（而且很容易！）。为了实现接近这样的功能，我不得不编写 chain 函数，这似乎与惯用法截然不同：

fn join<T>(x: Option<Option<T>>) -> Option<T> {
    if let Some(y) = x {
        y
    } else {
        None
    }
}

fn bind<A, B, F>(x: Option<A>, f: F) -> Option<B>
where
    F: FnOnce(A) -> Option<B>,
{
    join(x.map(f))
}

fn chain<A, B, C, F, G>(x: Option<A>, f: F, g: G) -> Option<C>
where
    F: FnOnce(A) -> Option<B>,
    G: FnOnce(B) -> Option<C>,
{
    bind(bind(x, f), g)
}

- qwe

Answer 1

如上所述，Option 和 Result 类型拥有大量实用方法。此外，try 运算符 (?) 还可用于极为常见的“返回错误或解开结果”的情况。

我会为 Face 和 Suit 实现 FromStr，这样你的代码看起来会像这样：

impl FromStr for Card {
    type Err = ();

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let face = s[0..1].parse()?;
        let suit = s[1..2].parse()?;

        Ok(Card { face, suit })
    }
}

如果您没有/无法这样做，您可以使用Option上的现有方法。您没有定义Foo :: from_usize ，因此我假设它返回Foo，所以它将使用map：

fn from_str(s: &str) -> Result<Self, Self::Err> {
    let mut c = s.chars();

    let face = c
        .next()
        .and_then(|c| FACES.find(c))
        .map(Face::from_usize)
        .ok_or(())?;
    let suit = c
        .next()
        .and_then(|c| SUITS.find(c))
        .map(Suit::from_usize)
        .ok_or(())?;

    Ok(Card { face, suit })
}

• Option::and_then方法
• Option::map方法
• Option::ok_or方法

这两种方法都可以让您拥有有用的错误，例如枚举类型，使您知道花色 / 面值是否缺失 / 无效。对于消费者来说，()类型的错误是没有用处的。

您还可以定义Suit::from_char和Face::from_char，并且不会将数组的实现细节泄露出去。

将它们全部结合起来：

impl Suit {
    fn from_char(c: char) -> Option<Self> {
        use Suit::*;

        [('c', C), ('d', D), ('h', H), ('s', S)]
            .iter()
            .cloned()
            .find(|&(cc, _)| cc == c)
            .map(|(_, s)| s)
    }
}

enum Error {
    MissingFace,
    MissingSuit,
    InvalidFace,
    InvalidSuit,
}

impl FromStr for Card {
    type Err = Error;

    fn from_str(x: &str) -> Result<Self, Self::Err> {
        use Error::*;

        let mut xs = x.chars();

        let face = xs.next().ok_or(MissingFace)?;
        let face = Face::from_char(face).ok_or(InvalidFace)?;
        let suit = xs.next().ok_or(MissingSuit)?;
        let suit = Suit::from_char(suit).ok_or(InvalidSuit)?;

        Ok(Card { face, suit })
    }
}

---

fn join<T>(x: Option<Option<T>>) -> Option<T>

这是 x.and_then（|y| y）

fn bind<A, B, F>(x: Option<A>, f: F) -> Option<B>
where
    F: FnOnce(A) -> Option<B>,

这是x.and_then(f)

fn chain<A, B, C, F, G>(x: Option<A>, f: F, g: G) -> Option<C>
where
    F: FnOnce(A) -> Option<B>,
    G: FnOnce(B) -> Option<C>,

这是 x.and_then(f).and_then(g)

另请参见:

• 如何在Option上实现一些便利的方法（例如flat_map、flatten）？

- Shepmaster

Answer 2

看起来你想要使用Option::and_then：

pub fn and_then<U, F>(self, f: F) -> Option<U> 
where
    F: FnOnce(T) -> Option<U>

例子：

fn sq(x: u32) -> Option<u32> { Some(x * x) }
fn nope(_: u32) -> Option<u32> { None }

assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16));
assert_eq!(Some(2).and_then(sq).and_then(nope), None);
assert_eq!(Some(2).and_then(nope).and_then(sq), None);
assert_eq!(None.and_then(sq).and_then(sq), None);

- Jorge Israel Peña

Answer 3

除了其他答案，您也可以查看单子表达式创建像mdo或map_for的板条箱。例如，使用map_for：

fn from_str(x: &str) -> Result<Self, Self::Err> {
    let mut xs = x.chars();
    map_for!{
        ax <- xs.next();
        f  <- FACES.find(ax);
        a  <- Face::from_usize(f);
        bx <- xs.next();
        s  <- SUITS.find(bx);
        b  <- Suit::from_usize (s);
        => Card::new(a, b) }
    .ok_or(Err(()))
}

完全公开：我是map_forcrate的作者。

- Jmb

Answer 4

Maybe 单子链在 Rust 的 Result 中是通过 try! 宏 实现的。应该看起来像这样：

fn from_str(x: &str) -> Result<Self, Self::Err> {
    let mut xs = x.chars();
    let a = try!(chain(xs.next(), |x| FACES.find(x), Face::from_usize));
    let b = try!(chain(xs.next(), |x| SUITS.find(x), Suit::from_usize));
    Ok(Card::new(face, suit))
}

- leftaroundabout

---

现在 ? 已经稳定下来了，我认为 try! 的时代已经过去了。let a = chain(xs.next(), |x| FACES.find(x), Face::from_usize)?; 看起来更好一些。 - Alec

有趣。这基本上是旧的 try! 的语法糖吗？ - leftaroundabout

@leftaroundabout，实际上它更好，因为它由Try trait支持，所以它更灵活。例如，它适用于Option，并且当它稳定后，它将可用于用户类型。 - Shepmaster