[Haskell-cafe] generalizing the writer monad

17 Oct 2012

      Hi,

(this is a literate Haskell post.)

lately I was playing with the Writer monad and it seems to me that it
is too tightly coupled with monoids. Currently, MonadWriter makes the
following assumptions:

(1) The written value can be read again later.
(2) For that to be possible it has to be monoid so that multiple (or
zero) values can be combined.

I fell say that this is a bit restricting. Sometimes, the written
value can be lost - either used to compute something else or for
example sent out using some IO action to a file, network etc. For
example, I'd like to create an IO-based writer monad whose `tell` logs
its argument somewhere - prints it, stores to a file etc.

So what I'm suggesting is to have another type class between Monad and
MonadWriter, let's say MonadTell, which only allows to write values,
not to retrieve them later:
...
{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, FunctionalDependencies #-}
import Control.Monad
import Control.Monad.Trans
import qualified Control.Monad.Writer as W
import qualified Control.Monad.Reader as R
import Data.Monoid
class Monad m => MonadTell w m where
    tell :: w -> m ()
    tell w = writer ((), w)
    writer :: (a, w) -> m a
    writer ~(a, w) = tell w >> return a
(We don't need fun.deps. here, they're needed in MonadWriter because
of `listen`. IDK if it'd be still better to add fun.dep. just to
eliminate typing problems?)

And MonadWriter would be defined by inheriting from MonadTell:
...
class (MonadTell w m, Monoid w) => MonadWriter' w m | m -> w where
    listen :: m a -> m (a, w)
    pass :: m (a, w -> w) -> m a
Now we could use MonadWriter as before, but we could also make more
generic writers like:
...
newtype Log = Log String deriving Show
-- Prints logs to stdout.
instance MonadTell Log IO where
    tell (Log s) = putStrLn s
-- Collects the length of written logs.
instance Monad m => MonadTell Log (W.WriterT (Sum Int) m) where
    tell (Log s) = W.tell (Sum $ length s)
main = do
    let l = Log "Hello world"
    tell l
    print . getSum . W.execWriter $ (tell l :: W.Writer (Sum Int) ())
The same applies to MonadReader. We could make another type class
between Monad and MonadReader just with `ask`:
...
class Monad m => MonadAsk r m | m -> r where
    ask :: m r
This would allow us to write instances like
...
instance MonadAsk Log IO where
    ask = liftM Log getLine
Does it make sense?

    Best regards,
    Petr Pudlak