What Is A Monad In C++

Introduction:

A monad in C++ (adapted from functional programming languages such as Haskell) is a pattern that facilitates the sequential execution of operations while handling values, contexts, or side effects in a structured way. Although C++ doesn't have built-in monads, developers can implement the concept by creating types that adhere to specific guidelines, enabling secure and flexible combination of computations.

Key Idea Behind Monads:

A monad is essentially a wrapper around a value or computation that allows chaining transformations and operations, maintaining a context. This context could represent something as shown below:

• ✅ Handling optional values (e.g., std::optional in C++ ).
• ✅ Managing errors or exceptions (e.g., std::expected, or future implementations of this kind).
• ✅ Dealing with asynchronous operations (e.g., std::future, std::promise).

Approach 1: Simple Approach

Implementation:

#include <iostream>
#include <optional>
// Function that returns std::optional<int> to simulate a monad-like structure
std::optional<int> add_five(int x) {
    return x + 5;
}
// Another function that operates in a monad-like structure
std::optional<int> multiply_by_two(int x) {
    return x * 2;
}
// Function to simulate 'and_then' for std::optional in older versions of C++
template <typename T, typename Func>
std::optional<T> optional_bind(std::optional<T> opt, Func func) {
    if (opt) {
        return func(*opt);  // Apply the function if value is present
    }
    return std::nullopt;    // Return std::nullopt if no value
}
int main() {
    // Wrapping a value in std::optional
    std::optional<int> value = 10;
    // Chain operations using custom 'optional_bind'
    std::optional<int> result = optional_bind(value, add_five);
    result = optional_bind(result, multiply_by_two);
    // Check if the result contains a value and print it
    if (result) {
        std::cout << "Final Result: " << *result << std::endl;
    } else {
        std::cout << "No result found!" << std::endl;
    }
    return 0;
}

Output:

Final Result: 30

Explanation:

• ✅ The std::optional type serves as a container that can hold either a value or nothing at all. This feature proves to be beneficial when dealing with situations where a value could be absent or incorrect.

Functions:

• ✅ Two functions are declared, one for adding a number and the other for multiplying it. Each function accepts an integer parameter and yields a std::optional containing the outcome.

Chaining Functions:

To mimic chaining (executing a sequence of functions), we establish a helper function. This function verifies the presence of a value within the std::optional. Should a value exist, the function proceeds with the subsequent operation; otherwise, it forwards the lack of a value.

Execution Flow:

• ✅ Start with an initial value wrapped in std::optional.
• ✅ Apply the first Function to the value.
• ✅ If the result of the first Function is valid, apply the second Function to this result.
• ✅ Check if the final result is valid and print it.

How does it work?

Initialization:

To start, you have a value that needs processing. This value is enclosed within a std::optional, enabling you to handle it securely, especially in cases where the value could be absent.

Processing:

• ✅ The bespoke function we employ verifies if the optional parameter holds a value. If it does, it executes the specified Function on this value.
• ✅ This mechanism enables cascading actions: the output of one Function serves as the input for the subsequent Function.

Result Management:

Following the execution of all functions, it is essential to verify the presence of a valid outcome. In case a valid result exists, it should be showcased; however, if there is no valid result, the situation must be addressed appropriately.

Complexity analysis:

Time Complexity

Initialization:

Enclosing a value within std::optional is an operation that runs in constant time complexity. This is due to the simple initialization of the std::optional instance with the provided value.

Function Applications:

Each function (addfive and multiplyby_two) runs in constant time, denoted as O(1). They execute a basic mathematical calculation and provide the output.

Chaining Operations:

Applying each Function consecutively is part of the chaining process. Because each Function is executed just once, and verifying the existence of a value in std::optional also has a time complexity of O(1), the total complexity for each step stays at O(1).

Overall Complexity:

The time complexity for the entire process, encompassing setup, executing functions, and linking them together, remains O(1) due to the constant time taken by each individual operation (such as encapsulating a value, executing a function, and verifying the outcome).

Space Complexity

Space for std::optional:

The memory needed for a std::optional<int> remains fixed at O(1) since it can hold a solitary integer or remain empty. The optional's size is independent of the integer's magnitude.

Space for Functions:

The addfive and multiplyby_two functions do not necessitate extra memory beyond their input and output. They work on integer values and produce new std::optional objects, which also maintain a consistent size.

Space for Chaining:

The space efficiency for chaining operations remains constant at O(1). This is due to the utilization of std::optional containers to store intermediate results, ensuring a fixed maximum number of instances created.

Overall Complexity:

The space efficiency of the complete process, encompassing memory allocation for the std::optional entities and the functions, remains at O(1). No dynamic memory allocation occurs, and there is no substantial increase in space consumption compared to the input size.

Approach 2: Using Function Objects for Chaining Operations

In this method, you create function objects (which are classes with the operator method) to execute calculations. You link these calculations together using composition, where each function object is applied to the output of the preceding one.

Implementation:

#include <iostream>
#include <optional>
// Define function objects (functors)
class AddFive {
public:
    std::optional<int> operator()(int x) const {
        return x + 5;
    }
};
class MultiplyByTwo {
public:
    std::optional<int> operator()(int x) const {
        return x * 2;
    }
};
//Function to apply function objects in sequence
template <typename Func1, typename Func2>
std::optional<int> chain_operations(std::optional<int> value, Func1 f1, Func2 f2) {
    if (value) {
        auto intermediate_result = f1(*value);
        if (intermediate_result) {
            return f2(*intermediate_result);
        }
    }
    return std::nullopt;
}
int main() {
    // Wrapping a value in std::optional
    std::optional<int> value = 10;
    // Create instances of function objects
    AddFive add_five;
    MultiplyByTwo multiply_by_two;
    // Chain operations using function objects
    std::optional<int> result = chain_operations(value, add_five, multiply_by_two);
    // Check if result contains a value and print it
    if (result) {
        std::cout << "Final Result: " << *result << std::endl;
    } else {
        std::cout << "No result found!" << std::endl;
    }
    return 0;
}

Output:

Final Result: 30

Explanation:

Define Function Objects:

Function objects are specialized classes that specify a particular computation task. Each class contains an operator method responsible for executing the computation. For instance, a function object might be designed to add values, while another could be intended for multiplication operations.

Chain Operations:

To execute a series of operations consecutively, you instantiate these function objects and apply them sequentially. Initially, you apply the first operation to the value, then proceed to apply the subsequent operation to the resulting value.

Handling Outcomes:

Once all procedures have been executed, it is essential to verify the presence of a value in the ultimate outcome. If a value is present, it can be utilized; otherwise, the scenario where there is no outcome must be addressed appropriately.

How does it work?

Defining Function Objects:

Operations are encapsulated within classes, each containing a method (operator) responsible for executing a particular action, like addition or multiplication. By utilizing these classes, you can craft adaptable and reusable operations.

Applying Functions:

Function objects are employed to manipulate a value that could be present or absent. When the initial value exists, the first function object is executed on it. If this operation is successful and yields a new value, the subsequent function object is then applied to this outcome.

After verifying the end result, you ensure its correctness. If the outcome meets the criteria, you utilize it accordingly; otherwise, you address the scenario where a valid result is unattainable.

Complexity Analysis:

Time Complexity

Initialization:

Enclosing a value within std::optional is a constant-time operation. This includes instantiating an std::optional instance and saving the value within it.

Function Objects:

Each function object (AddFive, MultiplyByTwo) executes its operation in constant time, denoted as O(1). This indicates that the process of adding or multiplying a number consumes a consistent and unchanging duration of time.

Chaining Operations:

Utilizing each function object requires invoking its operator function. Given that each function object executes its task in constant time and the chaining is done sequentially, the total time complexity for chaining remains O(1) for every Function applied.

Overall Complexity:

The overall time complexity of the complete procedure, encompassing setup, executing function objects, and linking operations, remains O(1). This is due to the fact that each individual stage (setting up std::optional, executing functions, and chaining) happens within constant time.

Space Complexity

Space for std::optional:

The memory needed for std::optional<int> remains constant at O(1), since it only holds an integer value or signifies the absence of a value. The std::optional's size does not increase based on the stored value.

Space for Function Objects:

The Function entities such as AddFive and MultiplyByTwo do not need extra memory space besides their basic internal state, which is usually minimal (sometimes only a single integer or none at all). Consequently, each function entity consumes O(1) space.

Space for Chaining:

The space complexity for chaining operations stays constant at O(1) since it involves a set number of std::optional instances and function objects without any dynamic memory allocation.

Overall Complexity:

The overall space complexity of the operation is O(1). This encompasses the memory allocated for std::optional instances and Function entities. The space utilization is independent of the input size and stays consistent.