📦 Monads

Layman’s Overview

graph TD
    A[Box] -->|Contains| B[Item 1]
    A -->|Contains| C[Item 2]
    A -->|Contains| D[Box with Item]
    D -->|Contains| E[Inner Item]

    click A "javascript:alert('This is a Monad. It can contain different items, but looks the same from outside.');" "Box as Monad"
    click D "javascript:alert('This box contains another item, showing the nesting ability of Monads.');" "Nested Box"

Boxes

Imagine you have a series of boxes, each of which can contain anything (like books, toys, or even another smaller box).

These boxes are like Monads: they can contain all sorts of things, but they look the same from the outside (just a box).

A key use of Monads in programming is that they allow us to handle the contents of the boxes in a unified way, without caring about what specifically is inside.

graph TD
    A[Box] -->|Contains| B[Book]
    A -->|Contains| C[Toy]

    B -->|Put Bookmark| B1[Book with Bookmark]
    C -->|Stick Label| C1[Toy with Label]

    subgraph "Magic Tool (Monad Function)"
    B1
    C1
    end

    style A fill:#f9f,stroke:#333
    style B fill:#bbf,stroke:#333
    style C fill:#bbf,stroke:#333
    style B1 fill:#bfb,stroke:#333
    style C1 fill:#bfb,stroke:#333

Performing Unified Operations on Boxes

Now, suppose you want to do something to each item inside the boxes, like putting a bookmark in each book, or sticking a label on each toy. It seems impossible to do this without opening the boxes, but if we use a special "magic" tool (in programming, this is the function provided by Monads), we can achieve this.

This tool can change the things inside the box through the box, without changing the box itself.

Summary

This is the core of Monads: they are a tool or pattern that allows us to manipulate encapsulated things (like data or values) while keeping the outer structure (the box) unchanged. This is very useful in programming because it makes the code neater, more predictable, and easier to manage.

In short, Monads are like a special kind of box that allows us to operate on the contents inside the box in a safe and unified way, without needing to open the box directly.

This helps us better manage and pass data in programming, especially when dealing with complex or uncertain situations.

Etymology

The word "Monad" originates from Greek, meaning "single" or "individual entity."

This term first appeared in the philosophical – refer to a singular, indivisible entity of the mind or soul.

In contemporary everyday English, the term "monad" is almost never used. It is primarily employed in mathematical, computer science, and programming contexts, especially in the realm of functional programming (encapsulate computations involving side effects, state changes, and other complex scenarios).

Elegance

Monads are elegant:

Unified Interface: Monads provide a unified interface for various operations and transformations, such as map, flatMap (or bind), and unit (or pure). This consistency makes it easier to learn and use different types of Monads.
Chain Calls: Monads allow developers to organize code in a chain-like manner, making the code more intuitive and readable. Chain calling also makes it concise to combine multiple operations in sequence.
Isolation of Side Effects: Monads provide an elegant way to handle side effects (such as IO operations, state changes, exception handling, etc.) while maintaining the purity and immutability of functions. This is crucial for writing predictable, testable, and maintainable code.
Composability: Monads can be combined together, making it more direct and concise to build complex operations and data processes. Composability also means that existing Monad logic can be reused, improving code maintainability.
Error Handling: Some Monads (like Scala’s Try or Either) are specifically used for error handling, providing an elegant way to manage and propagate errors, rather than using traditional exception handling mechanisms.
Transparency: Using Monads, programmers can write code that both expresses their intent and clearly states its side effects. This transparency makes the code easier to understand and maintain.
Powerful Abstraction: Monads are a powerful abstraction tool, allowing developers to write code in a declarative way, focusing more on what to do rather than how to do it.

Monads Design Pattern in Programming

Monad is a design pattern mainly used in functional programming languages

It provides a structure that allows programmers to handle side effects, state changes, and other programming challenges in a safe and consistent manner while keeping the code pure and composable.

In languages like Scala that support functional programming, Monads are widely used to build maintainable and readable code, especially when dealing with complex data flows and side effects. For example, Option, Either, and Future are common Monad instances in Scala.

To demonstrate the use of Monads in Scala, we can take Option Monad as an example. Option is a Monad representing optional values: it can be either Some(value) (indicating a value is present) or None (indicating no value). With this example, we can illustrate encapsulation and transformation of values, chain operations, and handling potential side effects (in this case, handling null values).

Encapsulation and Transformation of Values

Monads encapsulate a value and provide functions to operate on the encapsulated value, such as map and flatMap (also known as bind).

Example: Scala’s Option can encapsulate a value that might or might not exist. Using map and flatMap methods, we can transform this value without worrying about null issues.

val maybeNumber: Option[Int] = Some(5)
val maybeSquare: Option[Int] = maybeNumber.map(x => x * x) // Using map to transform value

Chain Operations

Using flatMap, we can link multiple operations together, each accepting a value and returning a new Option.
Example: Each operation returns a result in Monad form, allowing for smooth continuation of the next operation.

val result: Option[Int] = maybeNumber
   .flatMap(x => Some(x + 10)) // First add 10
   .flatMap(y => Some(y * 2))  // Then multiply the result by 2

Handling Side Effects

Option

Handle side effects such as input/output (IO), state management, exception handling, etc., without compromising the purity of functions.

Example: When dealing with potentially non-existent values, the Option Monad allows us to handle such cases safely, avoiding side effects like null pointer exceptions.

val maybeResult: Option[Int] = Some(3)
val finalResult: Int = maybeResult.getOrElse(0) // If the value does not exist, return 0

In this example, if maybeResult is None, the getOrElse method prevents the program from crashing and provides a default value.

Try

In Scala, Try is a Monad used for exception handling, representing a computation that might succeed (Success) or fail (Failure). Using Try as a Monad, we can elegantly handle operations that might throw exceptions. This approach is more functional than traditional try-catch exception handling, as it transforms exception handling into return value handling, allowing for more fluid error handling and data flow operations.

Here is an example using the Try Monad:

import scala.util.{Try, Success, Failure}

// Define a function that might throw an exception
def divide(x: Int, y: Int): Try[Int] = Try {
  if (y == 0) throw new ArithmeticException("Cannot divide by zero.")
  else x / y
}

// Use Try for operations and handle potential exceptions
val result = divide(10, 0) match { case Success(value) => s"Result: $value" case Failure(exception) => s"Error: ${exception.getMessage}" }

println(result) // Print error message

markdownCopy code

In this example:

The divide function attempts a division operation and might throw an ArithmeticException exception. This function returns Try[Int], which can be either Success[Int] (if the division is successful) or Failure (if an exception is thrown).
A match expression is used to handle the result of Try. If it’s Success, we get the result of the division; if it’s Failure, we get the exception message.
Finally, based on the result of Try, we output the corresponding message.

The advantages of using Try as a Monad include:

Unified Error Handling: Try provides a unified way to handle potentially erroneous operations, making the code clearer and more consistent.
Chain Operations: We can use methods like map and flatMap for chain operations on Try, making it simpler to handle a sequence of potentially erroneous operations.
Avoiding Explicit Exception Handling: Using Try can avoid the widespread use of try-catch blocks in the code, making the code more functional and expressive.

Laws of Monads

Understanding in Everyday Terms

Associativity:

Imagine you have a series of actions, such as placing a bookmark inside a book in a box, and then sticking a label on the book’s cover. Associativity is like saying that whether you first place the bookmark and then the label, or combine these two steps into one, the end result is that your book has both a bookmark and a label. This illustrates that regardless of the order of operations, the final outcome is the same.


graph LR
    A[Book in Box] -->|Place Bookmark| B[Book with Bookmark]
    B -->|Stick Label| C[Book with Bookmark and Label]

    A -->|Combine Operations| D[Book with Bookmark and Label]

    style A fill:#f9f,stroke:#333
    style B fill:#bbf,stroke:#333
    style C fill:#bfb,stroke:#333
    style D fill:#bfb,stroke:#333

Left Unit:

Left unit can be likened to starting from scratch. Suppose you have an empty box, and you put an item into the box (which is like encapsulating a value into a Monad), and then perform some operation on the item inside this box. The left unit law is akin to saying that performing this operation directly on the item and first placing the item in the box then performing the operation yield the same result.

graph LR
    A[Empty Box] -->|Place Item| B[Box with Item]
    B -->|Perform Operation| C[Box with Modified Item]
    D[Item] -->|Perform Operation| E[Modified Item]

    style A fill:#f9f,stroke:#333
    style B fill:#bbf,stroke:#333
    style C fill:#bfb,stroke:#333
    style D fill:#bbf,stroke:#333
    style E fill:#bfb,stroke:#333

Right Unit:

Right unit is about rules for maintaining the state of the box unchanged. Imagine you do nothing to the item inside the box, just open the box to take a peek and then close it again. This law suggests that even if you do this, the contents of the box remain the same as before, unchanged. In other words, applying an operation to a Monad that does not change its encapsulated value should not change the Monad itself.

graph LR
    A[Box with Item] -->|Open and Close Box| B[Box with Item Unchanged]
    A -->|Apply No-Change Operation| C[Box with Item Unchanged]

    style A fill:#f9f,stroke:#333
    style B fill:#bfb,stroke:#333
    style C fill:#bfb,stroke:#333

The Formal Laws

Associativity:
- The associativity law ensures that the sequence of flatMap operations does not affect the final result. Whether applying f first and then g, or immediately processing the result of f with g, the outcome should be the same.
- m.flatMap(f).flatMap(g) means applying f to m, then applying g to the result.
- m.flatMap(x => f(x).flatMap(g)) means applying f to m, and immediately applying g to the result of f.
- Both expressions should yield the same result, ensuring the consistency of flatMap operations.
Left Unit:
- The left unit law ensures that starting with a regular value, transforming it into a Monad, and then applying a function, is equivalent to directly applying the function to that value.
- unit(x).flatMap(f) means first encapsulating x into a Monad, then applying the function f.
- f(x) means directly applying the function f to x.
- If a Monad follows the left unit law, both approaches should yield the same result.
Right Unit:
- The right unit law ensures that applying a function to a Monad that simply returns its input value does not change
the Monad.
- m.flatMap(unit) means applying a function to the Monad m that simply returns its input.
- m is the unmodified original Monad.
- If a Monad follows the right unit law, applying such a function does not change the Monad.

Purrgramming

Archived Personal Finance and Computer Science Study Notes (for non-commercial use only)

(2) 📦 Monads