Combinators: map

match is a valid method for handling Options. However, you may
eventually find heavy usage tedious, especially with operations only valid
with an input. In these cases, combinators can be used to
manage control flow in a modular fashion.

Option has a built in method called map(), a combinator for the simple
mapping of Some -> Some and None -> None. Multiple map() calls can be
chained together for even more flexibility.

In the following example, process() replaces all functions previous
to it while staying compact.

  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. // Peeling food. If there isn't any, then return `None`.
  10. // Otherwise, return the peeled food.
  11. fn peel(food: Option<Food>) -> Option<Peeled> {
  12.     match food {
  13.         Some(food) => Some(Peeled(food)),
  14.         None       => None,
  15.     }
  16. }
  18. // Chopping food. If there isn't any, then return `None`.
  19. // Otherwise, return the chopped food.
  20. fn chop(peeled: Option<Peeled>) -> Option<Chopped> {
  21.     match peeled {
  22.         Some(Peeled(food)) => Some(Chopped(food)),
  23.         None               => None,
  24.     }
  25. }
  27. // Cooking food. Here, we showcase `map()` instead of `match` for case handling.
  28. fn cook(chopped: Option<Chopped>) -> Option<Cooked> {
  29.     chopped.map(|Chopped(food)| Cooked(food))
  30. }
  32. // A function to peel, chop, and cook food all in sequence.
  33. // We chain multiple uses of `map()` to simplify the code.
  34. fn process(food: Option<Food>) -> Option<Cooked> {
  35.     food.map(|f| Peeled(f))
  36.         .map(|Peeled(f)| Chopped(f))
  37.         .map(|Chopped(f)| Cooked(f))
  38. }
  40. // Check whether there's food or not before trying to eat it!
  41. fn eat(food: Option<Cooked>) {
  42.     match food {
  43.         Some(food) => println!("Mmm. I love {:?}", food),
  44.         None       => println!("Oh no! It wasn't edible."),
  45.     }
  46. }
  48. fn main() {
  49.     let apple = Some(Food::Apple);
  50.     let carrot = Some(Food::Carrot);
  51.     let potato = None;
  53.     let cooked_apple = cook(chop(peel(apple)));
  54.     let cooked_carrot = cook(chop(peel(carrot)));
  55.     // Let's try the simpler looking `process()` now.
  56.     let cooked_potato = process(potato);
  58.     eat(cooked_apple);
  59.     eat(cooked_carrot);
  60.     eat(cooked_potato);
  61. }

See also:

closures, Option, Option::map()