Why do we need monads?

by

Why do we need monads?

  1. We want to program only using functions. (“functional programming (FP)” after all).

  2. Then, we have a first big problem. This is a program:

    f(x) = 2 * x

    g(x,y) = x / y

    How can we say what is to be executed first? How can we form an ordered sequence of functions (i.e. a program) using no more than functions?

    Solution: compose functions. If you want first g and then f, just write f(g(x,y)). This way, “the program” is a function as well: main = f(g(x,y)). OK, but …

  3. More problems: some functions might fail (i.e. g(2,0), divide by 0). We have no “exceptions” in FP (an exception is not a function). How do we solve it?

    Solution: Let’s allow functions to return two kind of things: instead of having g : Real,Real -> Real (function from two reals into a real), let’s allow g : Real,Real -> Real | Nothing (function from two reals into (real or nothing)).

  4. But functions should (to be simpler) return only one thing.

    Solution: let’s create a new type of data to be returned, a “boxing type” that encloses maybe a real or be simply nothing. Hence, we can have g : Real,Real -> Maybe Real. OK, but …

  5. What happens now to f(g(x,y))? f is not ready to consume a Maybe Real. And, we don’t want to change every function we could connect with g to consume a Maybe Real.

    Solution: let’s have a special function to “connect”https://stackoverflow.com/”compose”https://stackoverflow.com/”link” functions. That way, we can, behind the scenes, adapt the output of one function to feed the following one.

    In our case: g >>= f (connect/compose g to f). We want >>= to get g‘s output, inspect it and, in case it is Nothing just don’t call f and return Nothing; or on the contrary, extract the boxed Real and feed f with it. (This algorithm is just the implementation of >>= for the Maybe type). Also note that >>= must be written only once per “boxing type” (different box, different adapting algorithm).

  6. Many other problems arise which can be solved using this same pattern: 1. Use a “box” to codify/store different meanings/values, and have functions like g that return those “boxed values”. 2. Have a composer/linker g >>= f to help connecting g‘s output to f‘s input, so we don’t have to change any f at all.

  7. Remarkable problems that can be solved using this technique are:

    • having a global state that every function in the sequence of functions (“the program”) can share: solution StateMonad.

    • We don’t like “impure functions”: functions that yield different output for same input. Therefore, let’s mark those functions, making them to return a tagged/boxed value: IO monad.

Total happiness!

More Related Contents:

  1. What is a monad?
  2. Good examples of Not a Functor/Functor/Applicative/Monad?
  3. Monads with Join() instead of Bind()
  4. Operating on a return from a Maybe that contains “Just”
  5. A monad is just a monoid in the category of endofunctors, what’s the problem?
  6. Is monad bind (>>=) operator closer to function composition (chaining) or function application?
  7. How to extract value from monadic action
  8. Large-scale design in Haskell? [closed]
  9. What is the purpose of the reader monad?
  10. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  11. Euler 43 – is there a monad to help write this list comprehension?
  12. Haskell: I/O and Returning From a Function
  13. Why does haskell’s bind function take a function from non-monadic to monadic
  14. Expressing do block using only monadic bind syntax
  15. Difference between Monad and Applicative in Haskell
  16. Defining a new monad in haskell raises no instance for Applicative
  17. What is a monad?
  18. Is there a way to place some impure code inside pure functions?
  19. What are free monads?
  20. Why are side-effects modeled as monads in Haskell?
  21. Converting IO Int to Int
  22. How to interpret bind/>>= of the function instance?
  23. Is there a monad that doesn’t have a corresponding monad transformer (except IO)?
  24. Why should Applicative be a superclass of Monad?
  25. How to handle side effect with Applicative?
  26. How to return a pure value from a impure method
  27. How does the ST monad work?
  28. In what sense is the IO Monad pure?
  29. How Monads are considered pure?
  30. Is Haskell’s mapM not lazy?

Leave a Comment