Pasted

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE MultiParamTypeClasses #-}
 
module Lib where
 
{-
This is a simple environment Monad transformer called simply E. It has no
use whatsoever except to show the basics of how to construct such a thing.
 
It turns out that it's easier in most cases to write a monad transformer
than it is to write a monad, because the "heavy lifting" can in most cases
be forwarded to the transformed monad. (At the cost of some efficiency,
though newtype helps a lot with this.)
 
Don't use this. Use ReaderT instead.
-}
 
import Control.Monad.IO.Class (MonadIO(..))
import Control.Monad.Reader.Class (MonadReader(..))
import Control.Monad.Trans (MonadTrans(..))
 
newtype E r m a = E { runE :: r -> m a }
 
instance Functor m => Functor (E r m) where
  fmap f (E a) = E $ fmap f . a 
 
instance Applicative m => Applicative (E r m) where
  pure = E . const . pure 
  (E f) <*> (E a) = E $ \r -> f r <*> a r
 
instance Monad m => Monad (E r m) where
  return = pure
  (E a) >>= f = E $ \r -> a r >>= \b -> runE (f b) r
 
instance MonadTrans (E r) where
  lift = E . const
 
instance MonadIO m => MonadIO (E r m) where
  liftIO = lift . liftIO
 
instance Monad m => MonadReader r (E r m)  where
  ask = E return 
  local t (E a) = E $ a . t