Monad: Inside out

Mathmatic-like function

(a: int) : int => 1 + a

Q1: What if a can be NULL

1 + NULL ???

Q2: What if 1 + a can be NULL

For Q1, most of languages fix this problem by add type int? (nullable int)

(a: int?) : int => 1 + a

It also fix Q2

(a: int?) : int? => 1 + a

Easy?

Is it easier if we are not allow a to be NULL in the first place?

Introduce Monad's return (or constructor)

(a: int) : int? => (nullable condition)? null : (int?)(1 + a)

//or

(a: int) : int? => (nullable condition)? int?.null() : int?.return(1 + a)

Let's write int? as Data type

data Maybe a = Nothing | Just a

Nothing is int?.null() and Just a is int?.return(a). In Haskell it's called constructor.

(a: int) : Maybe int => (nullable condition)? Nothing : Just(1 + a)

Wait, how to compose this:

let f = (a: int) : int? => (nullable condition)? Nothing : Just(1 + a)
f(f(a)) // compile error because f(a) return Maybe int, NOT int

Introduce Monad's bind

function bind(x: Maybe int, f : int => Maybe int) {
    return switch (x) {
        case Nothing: Nothing
        case Just a: f(a)
    }
}

now we can compose

let f = (a: int) : int? => (nullable condition)? Nothing : Just(1 + a)
bind(f(a), f)

other names of bind are flatMap, >>=, ...

virasak/monad-inside-out.md