What is a Monad?

A monad is a monoid in the category of endofunctors... ?

...let's try again:

A monad is an abstraction used in functional programming to handle computations in a consistent way. It is a design pattern that allows the chaining of operations while encapsulating side effects, such as state changes, I/O, or errors, in a controlled manner.

Monads can be thought of as a way to wrap values and apply functions to them, ensuring that computations are carried out in a predictable and controlled environment.

My personal understanding is: a monad is a data structure with

• a single, immutable value (or function)
• a map/bind function to map a function to that value
• a return/flatten function that returns the new state into a new monad each time

This enables chaining and composition of operations in a way that preserves immutability and functional purity—a "reverse" approach to a class, where state cannot be modified in-place, but transformations are applied functionally to produce new instances.

This "reverse symmetry" highlights the contrast:

• Classes modify their internal state, maintaining mutability and direct interaction through internal methods. They most of the time interact with a global state

• Monads reach similar outcomes to a class, but by wrapping values and mapping external immutable transformations, they have no side-effects: there is no global state

Example:

• Class: A Box class holds a value, and you can modify the value by calling methods like setValue(newValue), which mutates the internal state of the Box.
• Monad: A BoxMonad would hold a value in an immutable way. To transform the value, you would use a function like map, which applies an external function to the value and returns a new BoxMonad, with the new value.

Example project in Python:
https://github.com/blackopsrepl/py-monad-task-manager

In this application, we use the State Monad to manage the state of the task list. The State Monad provides a way to model the task management process as a series of transformations on the application's state, while keeping the state itself immutable.

Instead of directly modifying the state of the task list, we use the return_ function to wrap the initial state into a monadic container, and the bind function to apply transformations to the state in a predictable way. Each time an operation is performed (such as adding, editing, or deleting tasks), it returns a new instance of the state, ensuring immutability and composability.

Key functions:

• return_: Wraps a value into a monadic container, making it part of the monadic computation chain.
• bind: Applies a function to the value inside the monad, returning a new monadic container with the transformed value.

By using the State Monad, we can handle task management operations in a way that ensures the state is updated immutably and computations are composed without side effects or unwanted interactions between operations.