How to interpret bind/>>= of the function instance?

by

A few footnotes to Lee’s answer:

However, the bind function looks pretty weird. Why are f and g
nested the other way around?

Because bind is backwards. Compare (>>=) and its flipped version (=<<):

(>>=) :: Monad m => m a -> (a -> m b) -> m b
(=<<) :: Monad m => (a -> m b) -> m a -> m b

Or, in your specific example:

(>>=) :: (r -> a) -> (a -> (r -> b)) -> (r -> b)
(=<<) :: (a -> (r -> b)) -> (r -> a) -> (r -> b)

While in practice we tend to use (>>=) more often than (=<<) (because of how (>>=), syntactically speaking, lends itself well to the kind of pipeline monads are often used to build), from a theoretical point of view (=<<) is the most natural way of writing it. In particular, the parallels and differences with fmap/(<$>) and (<*>) are much more obvious:

(<$>) :: Functor f     =>   (a -> b) -> f a -> f b
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(=<<) :: Monad f       => (a -> f b) -> f a -> f b

When I apply apply/bind with an unary and a binary function, they yield the same result. This doesn’t make much sense.

That is an accidental fact about the function instances. Let’s put the specialised signatures side by side:

(<*>) :: (r -> (a -> b)) -> (r -> a) -> (r -> b)
(=<<) :: (a -> (r -> b)) -> (r -> a) -> (r -> b)

Monad goes beyond Applicative by providing the means to determine the next effect according to previous results (as opposed to “previous effect” — Applicative can do that already). The effect, in this case, consists of a function that generates values given an argument of type r. Now, since functions with multiple arguments (i.e. functions that return functions) can be flipped, it happens that there is no significant difference between (r -> (a -> b)) and (a -> (r -> b)) (flip can trivially change one into the other), which makes the Monad instance for (->) r entirely equivalent to the Applicative one.

More Related Contents:

  1. Applicatives compose, monads don’t
  2. What is a monad?
  3. Good examples of Not a Functor/Functor/Applicative/Monad?
  4. Is monad bind (>>=) operator closer to function composition (chaining) or function application?
  5. Large-scale design in Haskell? [closed]
  6. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  7. Should do-notation be avoided in Haskell?
  8. Applicative functor evaluation is not clear to me
  9. Difference between Monad and Applicative in Haskell
  10. What is a monad?
  11. How to use (->) instances of Monad and confusion about (->)
  12. Why are side-effects modeled as monads in Haskell?
  13. Why should Applicative be a superclass of Monad?
  14. How to enumerate a recursive datatype in Haskell?
  15. How to handle side effect with Applicative?
  16. How Monads are considered pure?
  17. Monads with Join() instead of Bind()
  18. How do you represent a graph in Haskell?
  19. Distinction between typeclasses MonadPlus, Alternative, and Monoid?
  20. What are “n+k patterns” and why are they banned from Haskell 2010?
  21. Expressing do block using only monadic bind syntax
  22. Why do we need monads?
  23. Pattern matching identical values
  24. Abusing the algebra of algebraic data types – why does this work?
  25. Haskell – depth for each node in binary tree using Reader monad
  26. How does the ST monad work?
  27. functions as applicative functors (Haskell / LYAH)
  28. How to compare two functions for extensional equivalence, as in (λx.2*x) == (λx.x+x)?
  29. ‘some’ and ‘many’ functions from the ‘Alternative’ type class [duplicate]
  30. Sampling sequences of random numbers in Haskell

Leave a Comment