Understanding Monads

Monads are a powerful concept in functional programming that helps manage side effects and represent computations as chains of steps. When you encounter situations where functions may fail or return optional values, Monads provide a way to handle these cases elegantly. In this lesson, our goal is to understand what Monads are, how they work, and how to implement and use them in C++ to manage std::optional values safely and predictably.

Consider a situation where you have a mock user database, and your task is to retrieve user information and then transform it into HTML format. Handling the absence of users or the failure of any step is crucial. Here's the example code that sets up our data and declares functions we want to implement.

#include <iostream>
#include <optional>
#include <string>
#include <unordered_map>

// Mock database
std::unordered_map<std::string, std::string> userDB = {
    {"user1", "John Doe"},
    {"user2", "Jane Smith"}
};

// Function to get user's full name
std::optional<std::string> user_full_name(const std::string& login);

// Function to convert text to HTML
std::optional<std::string> to_html(const std::string& text);

int main() {

}

Normally, we would approach this task with a functor from the previous lesson to handle optional values, but there is a problem: a functor wraps its answer into std::optional. If the answer is already an std::optional, we will get a nested optional structure, which is highly difficult to deal with.

In this lesson, we will implement a new version of our Functor – a Monad – which solves this problem.

A Monad is an abstraction that allows structuring programs generically. In our context, a Monad provides a way to sequence operations while handling potential failures gracefully. A Monad extends the functor's structure by adding a new method, called join.

Let's create a Monad:

template<typename T>
class Monad {
public:
    template<typename Func>
    auto transform(const std::optional<T>& value, Func func) -> std::optional<decltype(func(*value))> {
        if (value) {
            return func(*value);
        } else {
            return std::nullopt;
        }
    }

    std::optional<T> join(const std::optional<std::optional<T>>& nestedValue) {
        if (nestedValue) {
            return *nestedValue;
        } else {
            return std::nullopt;
        }
    }
};

It has a transform method, implemented in the same manner as in the Functor from the previous lesson. But we can't just use this method with our functions user_full_name and to_html, as they will return optional values, which will be additionally wrapped in optional by transform.

To address this, we provide a new method, called join. It is very simple – it just unwraps the optional, returning its value.