组合算子：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()