• 组合算子：map
    • 参见：

    组合算子：map

    match 是处理 Option 的一个有效方法。但是你最终会发现很多用例都相当繁琐，特别是操作只有一个有效输入的情况。在这些情况下，可以使用 组合算子（combinator）以模块化方式来管理控制流。

    Option 有一个内置方法 map()，这个组合算子可用于简单映射Some -> Some 和 None -> None 的情况。多个不同的 map() 调用可以更灵活地链式连接在一起。

    在下面例子中，process() 轻松取代了前面的所有函数，且更加紧凑。

    1. #![allow(dead_code)]
    3. #[derive(Debug)] enum Food { Apple, Carrot, Potato }
    5. #[derive(Debug)] struct Peeled(Food);
    6. #[derive(Debug)] struct Chopped(Food);
    7. #[derive(Debug)] struct Cooked(Food);
    9. // 削水果皮。如果没有水果，就返回 `None`。
    10. // 否则返回削好皮的水果。
    11. fn peel(food: Option<Food>) -> Option<Peeled> {
    12.     match food {
    13.         Some(food) => Some(Peeled(food)),
    14.         None       => None,
    15.     }
    16. }
    18. // 和上面一样，我们要在切水果之前确认水果是否已经削皮。
    19. fn chop(peeled: Option<Peeled>) -> Option<Chopped> {
    20.     match peeled {
    21.         Some(Peeled(food)) => Some(Chopped(food)),
    22.         None               => None,
    23.     }
    24. }
    26. // 和前面的检查类似，但是使用 `map()` 来替代 `match`。
    27. fn cook(chopped: Option<Chopped>) -> Option<Cooked> {
    28.     chopped.map(|Chopped(food)| Cooked(food))
    29. }
    31. // 另外一种实现，我们可以链式调用 `map()` 来简化上述的流程。
    32. fn process(food: Option<Food>) -> Option<Cooked> {
    33.     food.map(|f| Peeled(f))
    34.         .map(|Peeled(f)| Chopped(f))
    35.         .map(|Chopped(f)| Cooked(f))
    36. }
    38. // 在尝试吃水果之前确认水果是否存在是非常重要的！
    39. fn eat(food: Option<Cooked>) {
    40.     match food {
    41.         Some(food) => println!("Mmm. I love {:?}", food),
    42.         None       => println!("Oh no! It wasn't edible."),
    43.     }
    44. }
    46. fn main() {
    47.     let apple = Some(Food::Apple);
    48.     let carrot = Some(Food::Carrot);
    49.     let potato = None;
    51.     let cooked_apple = cook(chop(peel(apple)));
    52.     let cooked_carrot = cook(chop(peel(carrot)));
    53.     // 现在让我们试试更简便的方式 `process()`。
    54.     // （原文：Let's try the simpler looking `process()` now.）
    55.     // （翻译疑问：looking 是什么意思呢？望指教。）
    56.     let cooked_potato = process(potato);
    58.     eat(cooked_apple);
    59.     eat(cooked_carrot);
    60.     eat(cooked_potato);
    61. }

    参见：

    闭包, Option, 和 Option::map()