哈斯克尔。 提升 monad 错误和本地功能

Question

    data InterpreterM a = ExeInterpreter a | PropInterpreter a

    newtype InterpreterMT m a = InterpreterMT { runInterpreterMT :: m (InterpreterM a) }

    type Interpreter = InterpreterMT (StateT Int (ReaderT Int (ErrorT String IO)))
    data Stmts = Statements Stmt Stmts | EmptyStmts


  instance (Monad m) => Monad (InterpreterMT m) where
        return x = InterpreterMT $ return (ExeInterpreter x)
        x >>= f = InterpreterMT $ do
            m <- runInterpreterMT x 
            case m of
                (ExeInterpreter a) -> runInterpreterMT (f a)
    interpreter :: Stmts -> Interpreter ()
    interpreter EmptyStmts = return () 
    interpreter (Statements s stmts) = lift $ local (\x -> x) (interpreter stmts)





instance MonadTrans InterpreterMT where
    lift m = InterpreterMT $ do
        x <- m
        return $ ExeInterpreter x

Compiler gives me erorr in last line:

  Couldn't match type `InterpreterMT
                           (StateT Int (ReaderT Int (ErrorT String IO)))'
                  with `StateT Int (ReaderT Int (ErrorT String IO))'
    Expected type: Interpreter ()
      Actual type: InterpreterMT
                     (InterpreterMT (StateT Int (ReaderT Int (ErrorT String IO)))) ()
    In the expression: lift $ local (\ x -> x) (interpreter stmts)
    In an equation for `interpreter':
        interpreter (Statements s stmts)
          = lift $ local (\ x -> x) (interpreter stmts)

How to repair it and why it is an error?

Answer 1

Okay, two problems.

First, lift has the following signature:

lift :: (MonadTrans t, Monad m) => m a -> t m a

So you have to supply non-transformed monadic action to lift. In other words, you can't use InterpreterMT in an argument to lift .

So you would need to unwrap it:

lift $ local id $ runInterpreterMT $ interpreter stmts

But now your return types don't make sense: runInterpreterMT $ ... has type

StateT Int (ReaderT Int (ErrorT String IO)) (InterpreterM ())

or, shortening transformer stack to M ,

M (InterpreterM ())

while interpreter returns Interpreter () , which is

InterpreterMT (StateT Int (ReaderT Int (ErrorT String IO))) ()

or, shortening transformer stack,

InterpreterMT M ()

going back to type of lift , ma -> tma becomes M (InterpreterM ()) -> InterpreterMT M (InterpreterM ()) . (InterpreterM ()) is not () .

The root of the problem? Your InterpreterMT is not actually a monad transformer, since it doesn't really transform the monad. It transforms the value.

Easy fix? Provided that you can figure out a reasonable Monad instance for InterpreterMT (one you provided is doubtful), you can define a MonadReader instance for InterpreterMT :

instance MonadReader r m => MonadReader r (InterpreterMT m) where
  local f = InterpreterMT . local f . runInterpreterMT
  ...

(you'll need UndecideableInstances for this particular definition)

General pattern seems to be

inInterpreter f = InterpreterMT . f . runInterpreterMT

Note that this is not a Functor .

Not sure what you want to achieve here, but this whole design seems... underdeveloped. Maybe it's a good idea to go back to drawing board and figure out what exactly you want your architecture to be like.