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