Monadic operations with std::optional

In C++23, std::optional introduces support for monadic operations. These operations allow you to work with optional values in a more functional way, enabling you to chain operations together and handle empty optionals gracefully. The main monadic operations are and_then, or_else, and transform.

and_then()

This operation allows you to chain optional-producing operations. If the optional has a value, and_then applies the given function to the value, which should return another optional. If the original optional is empty, and_then returns an empty optional.

1#include <iostream>
2#include <optional>
3
4std::optional<int> square(int x) {
5  return x * x;
6}
7
8int main() {
9  std::optional<int> maybe_int = 10;
10  auto result = maybe_int.and_then(square);
11  if (result) {
12    std::cout << "Result: " << *result << '\n';
13  }
14
15  maybe_int = std::nullopt;
16  result = maybe_int.and_then(square);
17  if (!result) {
18    std::cout << "Result is empty" << '\n';
19  }
20}

This will output:

1Result: 100
2Result is empty

or_else()

This operation allows you to provide an alternative optional value if the original optional is empty. If the original optional has a value, or_else returns it. If the original optional is empty, or_else returns the result of the given function, which should return another optional.

1#include <iostream>
2#include <optional>
3
4std::optional<int> get_default() { return 42; }
5
6int main() {
7  std::optional<int> maybe_int = 10;
8  auto result = maybe_int.or_else(get_default);
9  std::cout << "Result: " << *result << '\n';
10
11  maybe_int = std::nullopt;
12  result = maybe_int.or_else(get_default);
13  std::cout << "Result: " << *result << '\n';
14}

This will output:

1Result: 10
2Result: 42

transform()

This operation allows you to apply a function to the value in an optional, if it exists. If the optional is empty, transform returns an empty optional.

1#include <iostream>
2#include <optional>
3
4int square(int x) { return x * x; }
5
6int main() {
7  std::optional<int> maybe_int = 10;
8  auto result = maybe_int.transform(square);
9  if (result) {
10    std::cout << "Result: " << *result << '\n';
11  }
12
13  maybe_int = std::nullopt;
14  result = maybe_int.transform(square);
15  if (!result) {
16    std::cout << "Result is empty" << '\n';
17  }
18}

This will output:

1Result: 100
2Result is empty

These monadic operations make it easier to work with std::optional in a functional style, allowing you to chain operations and handle empty optionals in a clear and concise way.