[Haskell-cafe] Nested Monads Questions

[Chris Kuklewicz]

I will try any make a simpler explanation:

> Hi
> 
> I'm trying to understand Monad Transformers. The code below works as
> expected but I have the following questions:
> - why can I use liftIO but not lift in the doSomething function?

Replacing liftIO with (lift . lift) does work:

> doSomething :: MyM Int
> doSomething = do
>    dataRef <- asks myData
>    logMsg "Writing"
>    lift . lift $ do
>        mv <- atomically $ readTVar dataRef
>        putStrLn mv
>    logMsg "Written"
>    return 1

This is because lift only move you one level though the MonadTrans stack of 
types.  Let's look at what MonadTrans means:

> class MonadTrans (t::(* -> *) -> * -> *) where
>   lift :: forall (m::* -> *) a. Monad m => m a -> t m a
>   	-- Imported from Control.Monad.Trans
> instance MonadTrans (ReaderT r)
>   	-- Imported from Control.Monad.Reader
> instance Monoid w => MonadTrans (WriterT w)
>   	-- Imported from Control.Monad.Writer

So the only thing MonadTrans does is provide the 'lift' function.  Your type is

> type MyM a = WriterT [Entry] (ReaderT MyData IO) a

To really see what (lift . lift) is doing, consider the most type specific:

> -- lift :: (MonadTrans t, Monad m) => m a -> t m a
> 
> liftIOtoReader :: IO a -> (ReaderT MyData) IO a
> liftIOtoReader = lift
> 
> liftReaderToWriter :: (ReaderT MyData IO) a -> (WriterT [Entry]) (ReaderT MyData IO) a
> liftReaderToWriter = lift
> 
> doSomething :: MyM Int
> doSomething = do
>    dataRef <- asks myData
>    logMsg "Writing"
>    liftReaderToWriter . liftIOtoReader $ do
>    --lift $ do
>        mv <- atomically $ readTVar dataRef
>        putStrLn mv
>    logMsg "Written"
>    return 1

In liftIOToReader, "m" is "IO" and "t" is (ReaderT MyData)
In liftReaderToWriter, "m" is (ReaderT MyData IO) and "t" is (WriterT [Entry])

So how does liftIO work?

The effect of the instances of liftIO recursively expand liftIO to (lift . 
liftIO) to (lift . (lift . liftIO)) to (lift . (lift . (lift . liftIO))) until 
it reaches the IO monad, where liftIO = id.

So it builds the correct number of composed calls to lift when it is compiled. 
And the same things could be done with STM or (ST s), or any other base monad.

Writing that sentence made me realize I could make a liftBase function to be a 
superset of liftIO, liftSTM, liftST:

> class (Monad m,Monad b) => MonadBase b m where
>   liftBase :: b a -> m a
> 
> instance MonadBase IO IO where liftBase = id
> instance MonadBase (ST s) (ST s) where liftBase = id
> instance MonadBase STM STM where liftBase = id
> 
> instance (MonadBase b m,Monoid a) => MonadBase b (WriterT a m) where liftBase = lift . liftBase
> instance (MonadBase b m) => MonadBase b (ReaderT a m) where liftBase = lift . liftBase

And so this now works:

> type MyM' s a = WriterT [String] (ReaderT Int (ST s)) a
> 
> testMyM' :: forall s. MyM' s Int
> testMyM' = do
>   tell ["a"]
>   foo <- lift (ask)
>   tell ["b"++show foo]
>   liftBase (go foo)
>  where go :: Int -> ST s Int
>        go f = do a <- newSTRef f
>                  modifySTRef a (+1)
>                  readSTRef a
> 
> main2 = do
>   let q = runST (runReaderT (runWriterT (testMyM')) 17 )
>   print q

> *Main> main2
> (18,["a","b17"])