haskell，如何处理不匹配的类型-monads

Question

I can't deal with following problem:
I have some function, that return foo :: a -> b -> ErrorT String IO Int
I know that it returns IO (Either String Int) .
Nevertheless, I have also more complex function, that returns:

bar :: a -> b -> StateT Char (ReaderT Char (ErrorT String IO)) Int

This function bar calls function foo . I am going to to following thing:
If foo called throwError bar also throws the same error. If foo returns Int bar also returns Int .

However, it is possible due to mismatch types.

I dont know how to do this in elegant way. I think that my order of transformator monad is not ok.

Answer 1

Something like this should work:

bar x y = do
  -- some code
  z <- lift $ lift $ foo x y
  -- some more code
  return z

Answer 2

What I typically do is using what I've dubbed Transformer Monad Classes :

{-# LANGUAGE FlexibleContexts #-}

import Control.Monad.Reader
import Control.Monad.State

inner :: ReaderT Char IO Int
inner = do
    a <- ask
    lift $ print a
    return 5

inner' :: (MonadReader Char m, MonadIO m) => m Int
inner' = do
    a <- ask
    liftIO $ print a
    return 5

outer :: StateT Char (ReaderT Char IO) Int
outer = do
    a <- get

    b <- lift $ inner    -- need to lift
    c <- inner'          -- no need to lift

    lift . lift $ print "need to lift twice to get to IO"            

    return 5

main = runReaderT (runStateT outer 'b') 'a'

Let's break it down; the first inner function has a concrete type you need to directly lift to in order to use it. However, if you parametrize it leaving only capabilities in the signature, you can skip the lifting, as long as it's unambiguous in the stack where to get this capability. In this case it's clear, because StateT Char (ReaderT Char IO) Int has exactly one instance for MonadIO (from IO ) and exactly one instance of MonadReader Char (from ReaderT ... Char ).

Now, it doesn't matter how many lifts you need to make, as long as the instance is clear! Consider:

outer' :: ErrorT String (StateT Char (ReaderT Char IO)) Int
outer' = do
    a <- inner'               -- still no need to lift!
    b <- lift . lift $ inner  -- need to double lift in this case
    return 5

The last thing that might not be obvious is that the signature of outer could be expressed in a generic way as well:

outer :: (MonadState Char m, MonadReader Char m, MonadIO m) => m Int

And it would still work without any lifts (well sans liftIO for IO operations, because functions like print are defined in terms of IO , not MonadIO m . In comparison, functions like ask and get are defined in terms of the respective MonadX class which allows us to skip the lifting).