A lot of people are frightened of Monads for no reason. Perhaps it's because their origins are based in Category Theory. Or that they are used extensively in Haskell. But neither of these need to be understood for the average Java/Scala programmer.

All that needs to be understood are the Monadic Laws (from Coursera):

__Monad Laws____Associativity__

(m flatMap f) flatMap g == m flatMap (x => f(x) flatMap g)

__Left unit__

unit(x) flatMap f == f(x)

__Right unit__

m flatMap unit == m

(think of unit as just a factory function).

**Note**: f(x) will return a monadic structure, that is: f is of type X => M[X] (if x is of type X and m is of type M in the above laws).

Like monoids, monads obey a few simple rules and that's that. So, what's so good about them?

Well, because monoids obey some laws, you can make assumptions about them (eg, when folding, you don't care if it's a left or right fold if you're using monoids).

With monads, you can make similar assumptions. For instance, given these simple functions:

def addOne(x: Int) : Int = x + 1

def times10(x: Int) : Int = x * 10

and this simple monad:

val option7 = Some(7)

then these two lines are exactly equivalent:

val outer = option7.flatMap(x => Some(times10(x))).flatMap(x => Some(addOne(x)))

val inner = option7.flatMap(x => Some(times10(x)).flatMap(x => Some(addOne(x))))

This is useful when dealing with for-comprehensions (which are just syntactic sugar).

Monads are also used a lot in Haskell as it's a lazy language and they make it actually do something (note: this is not my area of expertise).

__The Monad API__

Neither Scala nor Java 8 have a common trait or interface that all their monads implement even though they code. For instance, that's exactly what is done in Scalaz.

But, as mentioned, they're used in for-comprehensions in Scala so you might have been using them without even knowing! The compiler doesn't care that the monads don't have a common interface. It knows for-comprehension syntactic sugar can be converted to their respective map and flatMap methods. Then, using the monadic laws above, refactoring for-comprehensions is safe and easy.

__Conclusion__

So,

*what*monads are is easy.

*Why*they are useful is more subtle. Here is an interesting video on the subject of monads.

## No comments:

## Post a Comment