How to use (->) instances of Monad and confusion about (->)

by

For a given type r, the function of type r -> a can be thought of as a computation delivering an a using an environment typed r. Given two functions r -> a and a -> (r -> b), it’s easy to imagine that one can compose these when given an environment (again, of type r).

But wait! That’s exactly what monads are about!

So we can create an instance of Monad for (->) r that implements f >>= g by passing the r to both f and g. This is what the Monad instance for (->) r does.

To actually access the environment, you can use id :: r -> r, which you can now think of as a computation running in an environment r and delivering an r. To create local sub-environments, you can use the following:

inLocalEnvironment :: (r -> r) -> (r -> a) -> (r -> a)
inLocalEnvironment xform f = \env -> f (xform env)

This pattern of having an environment passed to computations that can then query it and modify it locally is useful for not just the (->) r monad, which is why it is abstracted into the MonadReader class, using much more sensible names than what I’ve used here:

http://hackage.haskell.org/packages/archive/mtl/2.0.1.0/doc/html/Control-Monad-Reader-Class.html

Basically, it has two instances: (->) r that we’ve seen here, and ReaderT r m, which is just a newtype wrapper around r -> m a, so it’s the same thing as the (->) r monad I’ve described here, except it delivers computations in some other, transformed monad.

More Related Contents:

  1. What is a monad?
  2. Applicatives compose, monads don’t
  3. What does (f .) . g mean in Haskell?
  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. What is a monad?
  9. Why are side-effects modeled as monads in Haskell?
  10. How to interpret bind/>>= of the function instance?
  11. How to enumerate a recursive datatype in Haskell?
  12. How Monads are considered pure?
  13. Getting started with Haskell
  14. How is this fibonacci-function memoized?
  15. What are paramorphisms?
  16. How do functors work in haskell?
  17. Euler 43 – is there a monad to help write this list comprehension?
  18. Why does haskell’s bind function take a function from non-monadic to monadic
  19. Difference between Monad and Applicative in Haskell
  20. Why is lazy evaluation useful?
  21. Is there a way to place some impure code inside pure functions?
  22. How to increment a variable in functional programming?
  23. What part of Hindley-Milner do you not understand?
  24. Abusing the algebra of algebraic data types – why does this work?
  25. How to return a pure value from a impure method
  26. How does the ST monad work?
  27. Functional lenses
  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