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()