I’m writing this down before I forget because it’s really cool. Imagine you have the following code
> g a b = (show a) ++ (show b)
> h = (+5)
> f x = g (h x) x
And you run f
through pointfree
, because you enjoy being made to look stupid. It’ll print up
> f' = g =<< h
You’ll stare at this going “I didn’t even say anything here was a Monad, but OK” try typing into your GHCi and… GHCi will tell you it doesn’t type check. Suitably chastened, you’ll go off to learn more Haskell elsewhere.
About a year later, you revist the problem and remember that all functions are examples of Reader monads and things start to make sense. You try
> import qualified Control.Monad.Reader
And, hey presto, it actually works. You can even check on the command line that it works. Let’s talk about how.
Reader, Illustrated
Start with a nice simple function x :: initial -> intermediate
. As long as we’ve got Control.Monad.Reader
imported, it’s automatically an m intermediate
, where m
means “a function taking an input
”.
Since it’s a monadic value, we can reasonably ask what (y =<< x)
is. Well, y
has got to be a function that is of the form b -> m result
. Since m
in this case is “a function taking an input
”, that makes y
an intermediate -> input -> result
. So the whole thing becomes input -> result
.
This finally explains to me why so much of the lens
library is written in terms of (MonadReader s m)
: it provides an extra free level of generality as long as you recall that (->) s
(which is a function that takes an s
) satisfies it. i.e. you can just read it as m b
as s -> b
.
Having fun
I don’t think I’ve ever published a FizzBuzz solution on the blog, so here’s one that heavily uses this reader monad trick.
> import Data.Maybe (Maybe(Just, Nothing), fromMaybe)
> import Data.Foldable (asum, for_)
> import qualified GHC.Base
> -- also provides the MonadReader instance
> toMaybe :: Bool -> a -> Maybe a
> toMaybe False _ = Nothing
> toMaybe _ value = Just value
> fizzbuzz :: Integer -> String
> fizzbuzz = fromMaybe <$> show <*> asum . sequence rules
> where fb m output n = toMaybe (n `mod` m == 0) output
> rules = [fb 15 "FizzBuzz", fb 3 "Fizz", fb 5 "Buzz"]
> main :: IO ()
> main = for_ [1..100] $ putStrLn . fizzbuzz
Code golfers welcome.