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.