组合算子：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. fn peel(food: Option<Food>) -> Option<Peeled> {
  11.     match food {
  12.         Some(food) => Some(Peeled(food)),
  13.         None       => None,
  14.     }
  15. }
  17. // 切食物。如果没有食物，就返回 `None`。否则返回切好的食物。
  18. fn chop(peeled: Option<Peeled>) -> Option<Chopped> {
  19.     match peeled {
  20.         Some(Peeled(food)) => Some(Chopped(food)),
  21.         None               => None,
  22.     }
  23. }
  25. // 烹饪食物。这里，我们使用 `map()` 来替代 `match` 以处理各种情况。
  26. fn cook(chopped: Option<Chopped>) -> Option<Cooked> {
  27.     chopped.map(|Chopped(food)| Cooked(food))
  28. }
  30. // 这个函数会完成削皮切块烹饪一条龙。我们把 `map()` 串起来，以简化代码。
  31. fn process(food: Option<Food>) -> Option<Cooked> {
  32.     food.map(|f| Peeled(f))
  33.         .map(|Peeled(f)| Chopped(f))
  34.         .map(|Chopped(f)| Cooked(f))
  35. }
  37. // 在尝试吃食物之前确认食物是否存在是非常重要的！
  38. fn eat(food: Option<Cooked>) {
  39.     match food {
  40.         Some(food) => println!("Mmm. I love {:?}", food),
  41.         None       => println!("Oh no! It wasn't edible."),
  42.     }
  43. }
  45. fn main() {
  46.     let apple = Some(Food::Apple);
  47.     let carrot = Some(Food::Carrot);
  48.     let potato = None;
  50.     let cooked_apple = cook(chop(peel(apple)));
  51.     let cooked_carrot = cook(chop(peel(carrot)));
  53.     // 现在让我们试试看起来更简单的 `process()`。
  54.     let cooked_potato = process(potato);
  56.     eat(cooked_apple);
  57.     eat(cooked_carrot);
  58.     eat(cooked_potato);
  59. }

参见：

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