/ Cats/Scala

What is a Monad?

You're probably already using monads but you may not realise it. If you've called flatMap on an Option or Future you're playing with monads. But what exactly are monads and why do we use them?

TL;DR - In very simple terms a Monad has a map and flatMap method and we use them for sequencing operations e.g. fetch a user based on her id, then fetch the orders associated with this user

What is a Monad?

A Monad is a Functor (has a map method) but it also has flatten and flatMap methods (flatMap is simply a combination of map and flatten).

Monads must obey certain laws. I don't believe it's necessary to fully understand these laws unless you're writing your own Monads so I won't go into them here. You can read more on the cats website. At this stage you just need to know that Future, Option, List and Either (Scala 2.12+) can all be thought of as Monads

What do we use Monads for?

We use the flatMap method to sequence effectful operations. In simple terms effectful means the operations return monads i.e. Future[String].flatMap(...): Future[A]

For comprehension is often used as syntactic sugar for flatMap calls:

def fetchUser(id: Int): Option[User] = ???
def fetchOrder(user: User): Option[Order] = ???

// <- is just a shortcut for flatMap
for {
  user <- fetchUser(1)
  order <- fetchOrder(user)
} yield (user, order)

We can always compose Functors but not necessarily Monads

What does this mean? It means that so long as we just make use of the map method, we can write generic code that can handle any stack of Functors e.g. List[Option[String]], Option[Future[String]] etc. However the moment we start to use flatMap or flatten we can no longer handle any Monad stack generically.

To understand why this is the case we need to think about structure. In the case of map we're only changing the innermost type i.e. Future[Option[String]] => Future[Option[Int]] so the only code that needs to be specific is the code to handle this innermost type, maybe parseInt in this example. We don't need anything specific to Futures and Options (the Functors).

However with flatten or flatMap we're actually changing the structure of the Monad stack e.g. a flatten call would transform Seq[Option[String]] => Seq[String] so we need something which understands that a None should not be included in the List but a Some should. We call this code a Monad Transformer

What next?

Lean about Monad transformers