diff --git a/List.cabal b/List.cabal
--- a/List.cabal
+++ b/List.cabal
@@ -1,5 +1,5 @@
 Name:                List
-Version:             0.3.0
+Version:             0.4.0
 Category:            Control
 Synopsis:            List monad transformer and class
 Description:
@@ -17,8 +17,7 @@
 Library
   hs-Source-Dirs:      src
   Extensions:
-  Build-Depends:       base >= 3 && < 5, mtl
+  Build-Depends:       base >= 3 && < 5, transformers >= 0.2.0
   Exposed-modules:     Control.Monad.ListT,
                        Data.List.Class
   Ghc-Options:         -O2 -Wall
-
diff --git a/src/Control/Monad/ListT.hs b/src/Control/Monad/ListT.hs
--- a/src/Control/Monad/ListT.hs
+++ b/src/Control/Monad/ListT.hs
@@ -7,17 +7,20 @@
 -- Monadic list example:
 --   A program which reads numbers from the user and accumulates them.
 --
+-- > import Control.Monad (join)
 -- > import Control.Monad.ListT (ListT)
--- > import Data.List.Class (execute, joinM, repeat, scanl, takeWhile)
+-- > import Control.Monad.Trans (lift)
+-- > import Data.List.Class (execute, repeat, scanl, takeWhile, mapL)
 -- > import Prelude hiding (repeat, scanl, takeWhile)
--- >
+-- > 
 -- > main =
--- >   execute . joinM . fmap print .
--- >   scanl (+) 0 .
--- >   fmap (fst . head) .
--- >   takeWhile (not . null) .
--- >   fmap reads .
--- >   joinM $ (repeat getLine :: ListT IO (IO String))
+-- >     execute . mapL print .
+-- >     scanl (+) 0 .
+-- >     fmap (fst . head) .
+-- >     takeWhile (not . null) .
+-- >     fmap reads $ do
+-- >       repeat ()
+-- >       lift getLine :: ListT IO String
 
 module Control.Monad.ListT (ListT(..)) where
 
@@ -25,11 +28,8 @@
 
 import Control.Applicative (Applicative(..))
 import Control.Monad (MonadPlus(..), ap, liftM)
--- import Control.Monad.Cont.Class (MonadCont(..))
-import Control.Monad.Error.Class (MonadError(..))
-import Control.Monad.Reader.Class (MonadReader(..))
-import Control.Monad.State.Class (MonadState(..))
-import Control.Monad.Trans (MonadTrans(..), MonadIO(..))
+import Control.Monad.IO.Class (MonadIO(..))
+import Control.Monad.Trans.Class (MonadTrans(..))
 import Data.Monoid (Monoid(..))
 
 newtype ListT m a =
@@ -79,32 +79,5 @@
   runList = runListT
   joinL = ListT . (>>= runList)
 
--- YUCK:
--- I can't believe I'm doing this,
--- for compatability with mtl's ListT.
--- I hate the O(N^2) code length auto-lifts. DRY!!
-
 instance MonadIO m => MonadIO (ListT m) where
   liftIO = lift . liftIO
-
-{-
--- TODO: understand and verify this instance :)
-instance MonadCont m => MonadCont (ListT m) where
-  callCC f =
-    ListT $ callCC thing
-    where
-      thing c = runListT . f $ ListT . c . (`Cons` mempty)
--}
-
-instance MonadError e m => MonadError e (ListT m) where
-  throwError = lift . throwError
-  catchError m = ListT . catchError (runList m) . (runList .)
-
-instance MonadReader s m => MonadReader s (ListT m) where
-  ask = lift ask
-  local f = ListT . local f . runList
-
-instance MonadState s m => MonadState s (ListT m) where
-  get = lift get
-  put = lift . put
-
diff --git a/src/Data/List/Class.hs b/src/Data/List/Class.hs
--- a/src/Data/List/Class.hs
+++ b/src/Data/List/Class.hs
@@ -14,7 +14,7 @@
   foldrL, foldlL, foldl1L, toList, lengthL, lastL,
   merge2On, mergeOn,
   -- | Operations useful for monadic lists
-  execute, joinM, iterateM, takeWhileM,
+  execute, joinM, mapL, iterateM, takeWhileM,
   -- | Operations for non-monadic lists
   sortOn,
   -- | Convert between List types
@@ -23,9 +23,9 @@
   ) where
 
 import Control.Monad (MonadPlus(..), liftM)
-import Control.Monad.Identity (Identity(..))
-import Control.Monad.State (StateT(..), evalStateT, get)
+import Control.Monad.Trans.State (StateT(..), evalStateT, get)
 import Data.Function (fix)
+import Data.Functor.Identity (Identity(..))
 import Data.List (sortBy)
 import Data.Maybe (fromJust)
 import Data.Ord (comparing)
@@ -140,6 +140,9 @@
   where
     consFunc action rest =
       liftM (`cons` joinL rest) action
+
+mapL :: List l => (a -> ItemM l b) -> l a -> l b
+mapL func = joinM . liftM func
 
 takeWhile :: List l => (a -> Bool) -> l a -> l a
 takeWhile = takeWhileM . fmap return