diff --git a/generator.cabal b/generator.cabal
--- a/generator.cabal
+++ b/generator.cabal
@@ -1,5 +1,5 @@
 Name:                generator
-Version:             0.5.3
+Version:             0.5.4
 Category:            Control
 Synopsis:            Python-generators notation for creation of monadic lists
 Description:
@@ -18,8 +18,6 @@
 Library
   hs-Source-Dirs:      src
   Extensions:
-  Build-Depends:       base >= 3 && < 5, mtl, MaybeT, List >= 0.2
-  Exposed-modules:     Control.Monad.DList,
-                       Control.Monad.Generator
+  Build-Depends:       base >= 3 && < 5, transformers, List >= 0.4
+  Exposed-modules:     Control.Monad.Generator
   Ghc-Options:         -O2 -Wall
-
diff --git a/src/Control/Monad/DList.hs b/src/Control/Monad/DList.hs
deleted file mode 100644
--- a/src/Control/Monad/DList.hs
+++ /dev/null
@@ -1,53 +0,0 @@
-{-# LANGUAGE TypeFamilies #-}
-
--- | A difference-list monad transformer / a monadic difference-list.
---
--- Difference lists are lists with /O(1)/ append (instead of /O(N)/).
---
--- Transforming a difference list to a list is /O(1)/,
--- a must be done to access a difference list.
--- The transformation from a list to a difference list is /O(N)/.
-
-module Control.Monad.DList (
-  DListT (..), toListT, joinDListT
-  ) where
-
-import Control.Applicative (Applicative(..))
-import Control.Monad (MonadPlus(..), liftM, ap)
-import Control.Monad.ListT (ListT)
-import Control.Monad.Trans (MonadTrans(..))
-import Data.List.Class (List(..), cons)
-import Data.Monoid (Monoid(..))
-
--- | A monadic difference-list
-newtype DListT m a = DListT { runDListT :: ListT m a -> ListT m a }
-
-toListT :: Monad m => DListT m a -> ListT m a
-toListT = (`runDListT` mzero)
-
-joinDListT :: Monad m => m (DListT m a) -> DListT m a
-joinDListT action =
-  DListT (joinL . (`liftM` action) . flip runDListT)
-
-instance Monoid (DListT l a) where
-  mempty = DListT id
-  mappend (DListT a) (DListT b) = DListT $ a . b
-
-instance Monad m => Functor (DListT m) where
-  fmap func = DListT . mplus . liftM func . toListT
-
-instance Monad m => Monad (DListT m) where
-  return = DListT . cons
-  a >>= b = DListT . mplus $ toListT a >>= liftM toListT b
-
-instance Monad m => Applicative (DListT m) where
-  pure = return
-  (<*>) = ap
-
-instance Monad m => MonadPlus (DListT m) where
-  mzero = mempty
-  mplus = mappend
-
-instance MonadTrans DListT where
-  lift = DListT . mappend . lift
-
diff --git a/src/Control/Monad/Generator.hs b/src/Control/Monad/Generator.hs
--- a/src/Control/Monad/Generator.hs
+++ b/src/Control/Monad/Generator.hs
@@ -1,37 +1,38 @@
+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, UndecidableInstances #-}
+
 -- | A monad transformer for the creation of Lists.
 -- Similar to Python's generators.
 --
--- > import Control.Monad.DList (toListT)
 -- > import Control.Monad.Identity (Identity(..))
 -- > import Data.List.Class (toList)
 -- >
--- > hanoi 0 _ _ _ = mempty
--- > hanoi n from to other =
--- >   generate $ do
--- >     yields $ hanoi (n-1) from other to
--- >     yield (from, to)
--- >     yields $ hanoi (n-1) other to from
+-- > hanoi 0 _ _ _ = return ()
+-- > hanoi n from to other = do
+-- >   hanoi (n-1) from other to
+-- >   yield (from, to)
+-- >   hanoi (n-1) other to from
 -- >
--- > > runIdentity . toList . toListT $ hanoi 3 'A' 'B' 'C' :: [(Char, Char)]
+-- > > runIdentity . toList . generate $ hanoi 3 'A' 'B' 'C' :: [(Char, Char)]
 -- > [('A','B'),('A','C'),('B','C'),('A','B'),('C','A'),('C','B'),('A','B')]
 --
 
 module Control.Monad.Generator (
-  GeneratorT, generate, yield, yields
+  GeneratorT(..), generate, yield, breakGenerator
   ) where
 
 import Control.Applicative (Applicative(..))
 import Control.Monad (liftM, ap)
-import Control.Monad.Cont (Cont (..))
-import Control.Monad.DList (DListT, joinDListT)
-import Control.Monad.Trans (MonadTrans(..), MonadIO(..))
+import Control.Monad.IO.Class (MonadIO(..))
+import Control.Monad.ListT (ListT)
+import Control.Monad.Trans.Class (MonadTrans(..))
+import Control.Monad.Trans.Cont (ContT (..), mapContT)
 import Data.List.Class (cons)
 import Data.Monoid (Monoid(..))
 
 -- | A monad transformer to create 'List's.
--- 'generate' transforms a "GeneratorT v m a" to a "DListT m a".
+-- 'generate' transforms a "GeneratorT v m a" to a "ListT m a".
 newtype GeneratorT v m a =
-  GeneratorT { runGeneratorT :: Cont (DListT m v) a }
+  GeneratorT { runGeneratorT :: ContT v (ListT m) a }
 
 instance Monad m => Functor (GeneratorT v m) where
   fmap = liftM
@@ -46,23 +47,19 @@
   (<*>) = ap
 
 instance MonadTrans (GeneratorT v) where
-  lift = GeneratorT . Cont . (joinDListT .) . flip liftM
-
-instance MonadIO m => MonadIO (GeneratorT v m) where
-  liftIO = lift . liftIO
+  lift = GeneratorT . lift . lift
 
--- | /O(1)/, Transform a GeneratorT to a 'DListT'
-generate :: Monad m => GeneratorT v m () -> DListT m v
-generate = ($ const mempty) . runCont . runGeneratorT
+generate :: Monad m => GeneratorT v m () -> ListT m v
+generate = (`runContT` const mempty) . runGeneratorT
 
-mkContNil :: (r -> r) -> Cont r ()
-mkContNil = Cont . (. ($ ()))
+modifyRes :: Monad m => (ListT m a -> ListT m a) -> GeneratorT a m ()
+modifyRes = GeneratorT . (`mapContT` return ())
 
--- | /O(1)/, Output a result value
 yield :: Monad m => v -> GeneratorT v m ()
-yield = GeneratorT . mkContNil . cons
+yield = modifyRes . cons
 
--- | /O(1)/, Output all the values of a 'DListT'.
-yields :: Monad m => DListT m v -> GeneratorT v m ()
-yields = GeneratorT . mkContNil . mappend
+breakGenerator :: Monad m => GeneratorT v m a
+breakGenerator = GeneratorT . ContT . const $ mempty
 
+instance MonadIO m => MonadIO (GeneratorT v m) where
+  liftIO = lift . liftIO