An Illustrated Reader

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.

Published by

Julian Birch

Full time dad, does a bit of coding on the side.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google+ photo

You are commenting using your Google+ account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s