Programming in Scala”

Chapter notes 30
That is, if we have a value x of type F[F[F[A]]], we can join twice to get F[A], or we can map join
over the outer F and then join the result of that.
This is saying that in “flattening” F[F[F[A]]] to F[A], it should not matter whether we first join the
two “inner” Fs or the two “outer” Fs. This is easy to see with the List monad. If we have a List of
Lists of Lists, like this…
val x: List[List[List[Int]]] =
List(List(List(1,2), List(3,4)), List(List(5,6), List(7,8)))
…it should not matter whether we flatten the inner lists or the outer lists first:
scala> val y1 = x.flatten
y1: List[List[Int]] = List(List(1, 2), List(3, 4), List(5, 6), List(7, 8))
scala> val y2 = x.map(_.flatten)
y2: List[List[Int]] = List(List(1, 2, 3, 4), List(5, 6, 7, 8))
scala> y1.flatten
res0: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)
scala> y2.flatten
res1: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8)
This is the same as saying that in the expression ((1 + 2) + (3 + 4)) + ((5 + 6) + (7 + 8)), it
doesn’t matter whether we remove the inner brackets first to get (1 + 2 + 3 + 4) + (5 + 6 + 7
+ 8) or the outer brackets first to get (1 + 2) + (3 + 4) + (5 + 6) + (7 + 8). In both cases we
end up with 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8. The reason it doesn’t matter is that + is associative.
So then it’s easy to see how the monad law is an associative law.
The identity laws in terms of join are similarly simple:
join(unit(x)) == x
// left identity
join(map(x)(unit)) == x // right identity
In terms of the list monad as above, the identity laws are saying that we can add brackets either on
the inside or the outside. Whichever we do, join will behave the same way: