Question about the Writer monad as taught in LYAH. (How did the appending to the log take place?)

Question

I'm learning Haskell from the "Learn you a Haskell for Great Good" tutorial and I've got to the part on writer monads. Here's the example that I can't figure out.

import Control.Monad.Writer

logNumber :: Int -> Writer [String] Int  
logNumber x = writer (x, ["Got number: " ++ show x])  

multWithLog :: Writer [String] Int  
multWithLog = do  
   a <- logNumber 3  
   b <- logNumber 5  
   return (a*b) -- shouldn't return (3*5) result in (15,[]) ?

ghci> runWriter $ multWithLog
(15,["Got number: 3","Got number: 5"]) -- how did that happen?

I am trying understand how the monoidic value w in the Writer w a monad returned by the do block got changed. The tutorial did not go into details on how the mappending took place.

The type declaration for Writer and the instance declaration for Writer as a monad is given by the tutorial as

newtype Writer w a = Writer { runWriter :: (a, w) }  

instance (Monoid w) => Monad (Writer w) where  
    return x = Writer (x, mempty)
    (Writer (x,v)) >>= f = let (Writer (y, v')) = f x in Writer (y, v `mappend` v')

if return x results in Writer (x, mempty) as per the instance declaration and mempty for monoid [a] is [], shouldn't return (a*b), which amounts to return (3*5), evaluate to (15,[])?

ghci> return (15) :: Writer [String] Int
WriterT (Identity (15,[]))

I gave the above command to ghci and it returns a WriterT type value, the tuple contains an empty list as expected.

multWithLog :: Writer [String] Int
multWithLog = logNumber 3 >>= (\a -> 
              logNumber 5 >>= (\b -> 
              return (a*b)))

I've rewritten the do block using bind operators instead. The above code gave identical result as the original code in the tutorial.

I'm under the impression that >>= only extracted Int 3 from the result of logNumber 3 and gave it to (\a -> logNumber 5 ...etc.), which then did the logNumber function on a different value (5) and so on. How did these operations lead to the [String] part of the Writer monad being altered?

I think you might be confused about what return means in Haskell - which is pretty common, so don't feel bad about it. In most imperative languages a return x at the bottom of a function definition means that the result of the function is x. But return in Haskell is just a function, and the actual value of multWithLog is the expression obtained from evaluating that entire do block, not just the last line with return. In particular the successive lines of the do block are connected by applications of >>=, and it is this which appends the log values "behind the scenes". — Robin Zigmond
"I'm under the impression that >>= only extracts Int 3 ...". That's where you are wrong. Only 3 is passed as the argument to the next function, but m >>= f doesn't simply return whatever f returns. It creates a new Writer value using both m and the return value of f. — chepner

chi chi · Accepted Answer · 2019-03-28T13:14:30

From the code you posted

(Writer (x,v)) >>= f =
   let (Writer (y, v')) = f x in Writer (y, v `mappend` v')

we can see that indeed f is being called only with the x argument. So in logNumber 3 >>= \a -> ... variable a indeed is bound to 3.

However, >>= does something after calling f, namely it combines v with v'. In your example, v is the [String] coming from logNumber 3 which is ["Got number: 3"]. Instead v' comes form evaluating \a -> ... with a=3, and is ["Got number: 5"].

mappend for lists is ++, which concatenates the lists together. Hence we get the final result.

Allow me to be a little sloppy and neglect the Writer wrappers. We get

return (a*b)
= (a*b, [])

logNumber 5 >>= \b -> return (a*b) 
= logNumber 5 >>= \b -> (a*b, [])
= (5, ["Got number: 5"]) >>= \b -> (a*b, [])
= (a*5, ["Got number: 5"] `mappend` [])
= (a*5, ["Got number: 5"])

logNumber 3 >>= \a -> logNumber 5 >>= \b -> return (a*b)
= logNumber 3 >>= \a -> (a*5, ["Got number: 5"])
= (3, ["Got number: 3"]) >>= \a -> (a*5, ["Got number: 5"])
= (3*5, ["Got number: 3"] `mappend` ["Got number: 5"])
= (15, ["Got number: 3", "Got number: 5"])

Intuitively, we can pretend that a value in your writer monad is an effectful computation, which returns a value (like 3) and as a side effect appends a few messages to a list-of-strings. The log of all such messages is invisible inside the monad (we can only append to the log), and will only be made available at the very end, when we will use runWriter to exit from the monadic context.

Question about the Writer monad as taught in LYAH. (How did the appending to the log take place?)

2 Answers