Monadic operations in C++23

If you are a C++ developer, and you have not been living under a rock, you certainly know that C++23 is finalized! One of my favourite addition is monadic operations.

Before diving into the details, let’s take a step back and try to define a monad. I will give a very simple (maybe incomplete) definition, that comes from a software developer perspective. For the purpose of this discussion a monad M that accepts a type T provides a set of operations:

A constructor or factory function that accepts any type T and “lifts” it to the monadic type.
An operation transform that takes as input a monad M<T> and a function
```
S f(T t);
```
and returns a M<S>, with S being the result of f(t), if M<T> exists, or a default monadic value if M<T> does not exist.
An operation and_then that takes as as input a monad M<T> and a function
```
M<S> f(T t);
```
and returns a M<S>, with M<S> being the result of f(t), if M<T> exists, or a default monadic value if M<T> does not exist.
An operation or_else that takes as as input a monad M<T> and a function, and returns M<T> if it exists or executes the function.

If you are wondering what is the difference between transform and and_then I got you covered! Simply put, if you where to apply transform to a function

M<S> f(T t);

you could get the output M<M<S>> so and_then simply flattens the result of applying f to t.

By this definition of monad in C++23 optional became a monadic type! To understand why we care let’s look at a simple example.

Let’s say I want to compute the square root of a number, later I will add 42 to this number. Using c++17 optional an implementation might look like this

#include <cmath>
#include <optional>
#include <iostream>

std::optional<float> my_sqrt(float x){
    return x > 0  ? std::make_optional(sqrtf(x)) : std::nullopt; 
}

float my_add_42(float x){
 return x + 42;
}

int main(){
    const std::optional<float> x = 144; 
    std::optional<float> out = std::nullopt; /* (1) */ 
    auto sqrt_x = my_sqrt(*x); 
    if (sqrt_x.has_value()){                 /* (2) */   
        out = my_add_42(*sqrt_x);
    }

    std::cout << out.value_or(-1) << std::endl;  
}

In the snippet, if x is a negative numer or std::nullopt, I will get -1, otherwise the value of the operation will be displayed. We deal with the condition that my_sqrt could return an empty optional by checking if the result has a value (2). This is not ideal because breaks the logic flow. Also I am forced to first initialize the out variable (1) and then assign a value to it. Using the power of monadic operations in c++23 we can craft a cleaner solution

#include <cmath>
#include <optional>
#include <iostream>

std::optional<float> my_sqrt(float x){
    return x > 0  ? std::make_optional(sqrtf(x)) : std::nullopt; 
}

float my_add_42(float x){
 return x + 42;
}

int main(){
    const std::optional<float> x = 44;
    const std::optional<float> out = 
        x.and_then(my_sqrt)
         .transform(my_add_42)
         .or_else( [](){return std::make_optional<float>(-1); }); 

    std::cout << *out << std::endl; 
}

This code is functionally equivalent to the previous snippet but it has three main advantages:

Reduced use of if statements.
output variable is assigned in only one statement, so it can be const.
Easy chaining of operations leading to fluent API.

optional is not the only type to implement monadic operations. A similar interface is implemented by expected, that I will describe in a future post.

Categories