Combinators: and_then

map() was described as a chainable way to simplify match statements.
However, using map() on a function that returns an Option<T> results
in the nested Option<Option<T>>. Chaining multiple calls together can
then become confusing. That’s where another combinator called and_then(),
known in some languages as flatmap, comes in.

and_then() calls its function input with the wrapped value and returns the result. If the Option is None, then it returns None instead.

In the following example, cookable_v2() results in an Option<Food>.
Using map() instead of and_then() would have given an
Option<Option<Food>>, which is an invalid type for eat().

  1. #![allow(dead_code)]
  3. #[derive(Debug)] enum Food { CordonBleu, Steak, Sushi }
  4. #[derive(Debug)] enum Day { Monday, Tuesday, Wednesday }
  6. // We don't have the ingredients to make Sushi.
  7. fn have_ingredients(food: Food) -> Option<Food> {
  8.     match food {
  9.         Food::Sushi => None,
  10.         _           => Some(food),
  11.     }
  12. }
  14. // We have the recipe for everything except Cordon Bleu.
  15. fn have_recipe(food: Food) -> Option<Food> {
  16.     match food {
  17.         Food::CordonBleu => None,
  18.         _                => Some(food),
  19.     }
  20. }
  22. // To make a dish, we need both the ingredients and the recipe.
  23. // We can represent the logic with a chain of `match`es:
  24. fn cookable_v1(food: Food) -> Option<Food> {
  25.     match have_ingredients(food) {
  26.         None       => None,
  27.         Some(food) => match have_recipe(food) {
  28.             None       => None,
  29.             Some(food) => Some(food),
  30.         },
  31.     }
  32. }
  34. // This can conveniently be rewritten more compactly with `and_then()`:
  35. fn cookable_v2(food: Food) -> Option<Food> {
  36.     have_ingredients(food).and_then(have_recipe)
  37. }
  39. fn eat(food: Food, day: Day) {
  40.     match cookable_v2(food) {
  41.         Some(food) => println!("Yay! On {:?} we get to eat {:?}.", day, food),
  42.         None       => println!("Oh no. We don't get to eat on {:?}?", day),
  43.     }
  44. }
  46. fn main() {
  47.     let (cordon_bleu, steak, sushi) = (Food::CordonBleu, Food::Steak, Food::Sushi);
  49.     eat(cordon_bleu, Day::Monday);
  50.     eat(steak, Day::Tuesday);
  51.     eat(sushi, Day::Wednesday);
  52. }

See also:

closures, Option, and Option::and_then()