Q:

Own Monad Transformer and lifting

data InterpreterM a = ExeInterpreter a | PropInterpreter a

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

instance (Monad m) => Monad (InterpreterMT m) where
    return x = lift .  return
    x >>= f = InterpreterMT $ do
        m <- runInterpreterMT x
        case m of
            (ExeInterpreter a) -> runInterpreterMT (f a) 

instance MonadTrans InterpreterMT where
    lift m = lift .   (ExeInterpreter m)

I've got error, and I don't know why:
Interpreter.hs:25:20:
    Couldn't match expected type `InterpreterMT m a'
                with actual type `a2 -> t1 m1 a2'
    In the expression: lift .  return
    In an equation for `return': return x = lift .  return
    In the instance declaration for `Monad (InterpreterMT m)'

Interpreter.hs:32:18:
    Couldn't match expected type `InterpreterMT m a'
                with actual type `a0 -> t0 m0 a1'
    In the expression: lift . ( ExeInterpreter m)
    In an equation for `lift': lift m = lift . ( ExeInterpreter m)
    In the instance declaration for `MonadTrans InterpreterMT'

Interpreter.hs:32:27:
    Couldn't match expected type `a0 -> m0 a1'
                with actual type `InterpreterM (m a)'
    In the return type of a call of `ExeInterpreter'
    Probable cause: `ExeInterpreter' is applied to too many arguments
    In the second argument of `(.)',  namely `(ExeInterpreter m)'
    In the expression: lift . ( ExeInterpreter m)

A:

What nicolas said.  I didn't use the point-free style, so it might be a little bit easier to understand the types.  You can look into example implementations to get a better feeling for transformers - Control. Monad. Trans. Class
data InterpreterM a = ExeInterpreter a
                    | PropInterpreter a

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

instance (Monad m) => Monad (InterpreterMT m) where

--  return :: Monad m => a -> InterpreterMT m a
    return x = InterpreterMT $ (return .  ExeInterpreter) x

-- or after you defined MonadTrans below
--  return x = lift .  return $ x

--  (>>=) :: Monad m => InterpreterMT m a -> (a -> InterpreterMT m b) -> InterpreterMT m b
    (>>=) ima f = InterpreterMT $ do
        ia <- runInterpreterMT ima
        case ia of
            (ExeInterpreter  a) -> runInterpreterMT $ f a
            (PropInterpreter a) -> runInterpreterMT $ f a

instance MonadTrans InterpreterMT where

--  lift :: Monad m => m a -> InterpreterMT m a
    lift ma = InterpreterMT $ (return .  ExeInterpreter) =<< ma

A:

You dont seem to have any instance of MonadTrans in context so lift does not exist. 
But more importantly, look at the type of the functions. 
x is a value of type a  and return x needs to give an element of type (InterpreterMT m) a.
For this you need to use the data constructor InterpreterMT and give it a  m (InterpreterM a)
which means the body of return should be like 
return .  PropInterpreter $ x

