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.