diff --git a/List.cabal b/List.cabal
--- a/List.cabal
+++ b/List.cabal
@@ -1,5 +1,5 @@
 Name:                List
-Version:             0.5.2
+Version:             0.6.0
 Category:            Control
 Synopsis:            List monad transformer and class
 Description:
@@ -19,7 +19,6 @@
   Extensions:
   Build-Depends:       base >= 3 && < 5, transformers >= 0.2
   Exposed-modules:     Control.Monad.ListT,
-                       Control.Monad.Trans.List,
-                       Control.Monad.Trans.List.Funcs,
+                       Control.Monad.ListT.Funcs,
                        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
@@ -1,8 +1,82 @@
--- Alternative module name to "List"'s @Control.Monad.Trans.List@.
--- The name @Control.Monad.Trans.List@ conflicts with "transformers"'s broken ListT.
+{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, StandaloneDeriving, TypeFamilies, UndecidableInstances #-}
+
+-- | A list monad transformer / a monadic list.
 --
--- Import this module and not @Control.Monad.Trans.List@ if using both packages.
+-- Monadic list example:
+--   A program which reads numbers from the user and accumulates them.
+--
+-- > import Control.Monad.ListT.Funcs (repeatM)
+-- > import Data.List.Class (execute, scanl, takeWhile, mapL)
+-- > import Prelude hiding (scanl, takeWhile)
+-- >
+-- > main =
+-- >     execute . mapL print .
+-- >     scanl (+) 0 .
+-- >     fmap (fst . head) .
+-- >     takeWhile (not . null) .
+-- >     fmap reads $ repeatM getLine
+--
+-- Note:
+-- The `transformers` package also has a `ListT` type,
+-- which oddly enough it is not a list monad transformer.
+-- This module was deliberately named differently from `transformers`'s module.
 
 module Control.Monad.ListT (ListT(..)) where
 
-import Control.Monad.Trans.List (ListT(..))
+import Data.List.Class (List(..), ListItem(..), foldrL)
+
+import Control.Applicative (Alternative(..), Applicative(..))
+import Control.Monad (MonadPlus(..), ap, liftM)
+import Control.Monad.IO.Class (MonadIO(..))
+import Control.Monad.Trans.Class (MonadTrans(..))
+import Data.Monoid (Monoid(..))
+
+newtype ListT m a =
+    ListT { runListT :: m (ListItem (ListT m) a) }
+
+deriving instance (Eq (m (ListItem (ListT m) a))) => Eq (ListT m a)
+deriving instance (Ord (m (ListItem (ListT m) a))) => Ord (ListT m a)
+deriving instance (Read (m (ListItem (ListT m) a))) => Read (ListT m a)
+deriving instance (Show (m (ListItem (ListT m) a))) => Show (ListT m a)
+
+-- for mappend, fmap, bind
+foldrL' :: List l => (a -> l b -> l b) -> l b -> l a -> l b
+foldrL' consFunc nilFunc =
+    joinL . foldrL step (return nilFunc)
+    where
+        step x = return . consFunc x . joinL
+
+instance Monad m => Monoid (ListT m a) where
+    mempty = ListT $ return Nil
+    mappend = flip (foldrL' cons)
+
+instance Monad m => Functor (ListT m) where
+    fmap func = foldrL' (cons . func) mempty
+
+instance Monad m => Monad (ListT m) where
+    return = ListT . return . (`Cons` mempty)
+    a >>= b = foldrL' mappend mempty (fmap b a)
+
+instance Monad m => Applicative (ListT m) where
+    pure = return
+    (<*>) = ap
+
+instance Monad m => Alternative (ListT m) where
+    empty = mempty
+    (<|>) = mappend
+
+instance Monad m => MonadPlus (ListT m) where
+    mzero = mempty
+    mplus = mappend
+
+instance MonadTrans ListT where
+    lift = ListT . liftM (`Cons` mempty)
+
+instance Monad m => List (ListT m) where
+    type ItemM (ListT m) = m
+    runList = runListT
+    joinL = ListT . (>>= runList)
+    cons x = ListT . return . Cons x
+
+instance MonadIO m => MonadIO (ListT m) where
+    liftIO = lift . liftIO
diff --git a/src/Control/Monad/ListT/Funcs.hs b/src/Control/Monad/ListT/Funcs.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/ListT/Funcs.hs
@@ -0,0 +1,24 @@
+-- | @List@ functions with type limited to use @ListT@.
+-- This might come useful for type interference.
+--
+-- Functions where the @List@ is an input type and not only the result type do not need special limited versions.
+
+module Control.Monad.ListT.Funcs
+    ( iterateM, repeatM, repeat, fromList
+    ) where
+
+import Control.Monad.ListT (ListT)
+import qualified Data.List.Class as ListFuncs
+import Prelude hiding (repeat)
+
+iterateM :: Monad m => (a -> m a) -> m a -> ListT m a
+iterateM = ListFuncs.iterateM
+
+repeatM :: Monad m => m a -> ListT m a
+repeatM = ListFuncs.repeatM
+
+repeat :: Monad m => a -> ListT m a
+repeat = ListFuncs.repeat
+
+fromList :: Monad m => [a] -> ListT m a
+fromList = ListFuncs.fromList
diff --git a/src/Control/Monad/Trans/List.hs b/src/Control/Monad/Trans/List.hs
deleted file mode 100644
--- a/src/Control/Monad/Trans/List.hs
+++ /dev/null
@@ -1,77 +0,0 @@
-{-# LANGUAGE FlexibleInstances, MultiParamTypeClasses, StandaloneDeriving, TypeFamilies, UndecidableInstances #-}
-
--- | A list monad transformer / a monadic list.
---
--- Monadic list example:
---   A program which reads numbers from the user and accumulates them.
---
--- > import Control.Monad.Trans.List.Funcs (repeatM)
--- > import Data.List.Class (execute, scanl, takeWhile, mapL)
--- > import Prelude hiding (scanl, takeWhile)
--- > 
--- > main =
--- >     execute . mapL print .
--- >     scanl (+) 0 .
--- >     fmap (fst . head) .
--- >     takeWhile (not . null) .
--- >     fmap reads $ repeatM getLine
-
-module Control.Monad.Trans.List (ListT(..)) where
-
-import Data.List.Class (List(..), ListItem(..), foldrL)
-
-import Control.Applicative
-import Control.Monad (MonadPlus(..), ap, liftM)
-import Control.Monad.IO.Class (MonadIO(..))
-import Control.Monad.Trans.Class (MonadTrans(..))
-import Data.Monoid (Monoid(..))
-
-newtype ListT m a =
-    ListT { runListT :: m (ListItem (ListT m) a) }
-
-deriving instance (Eq (m (ListItem (ListT m) a))) => Eq (ListT m a)
-deriving instance (Ord (m (ListItem (ListT m) a))) => Ord (ListT m a)
-deriving instance (Read (m (ListItem (ListT m) a))) => Read (ListT m a)
-deriving instance (Show (m (ListItem (ListT m) a))) => Show (ListT m a)
-
--- for mappend, fmap, bind
-foldrL' :: List l => (a -> l b -> l b) -> l b -> l a -> l b
-foldrL' consFunc nilFunc =
-    joinL . foldrL step (return nilFunc)
-    where
-        step x = return . consFunc x . joinL
-
-instance Monad m => Monoid (ListT m a) where
-    mempty = ListT $ return Nil
-    mappend = flip (foldrL' cons)
-
-instance Monad m => Functor (ListT m) where
-    fmap func = foldrL' (cons . func) mempty
-
-instance Monad m => Monad (ListT m) where
-    return = ListT . return . (`Cons` mempty)
-    a >>= b = foldrL' mappend mempty (fmap b a)
-
-instance Monad m => Applicative (ListT m) where
-    pure = return
-    (<*>) = ap
-
-instance Monad m => MonadPlus (ListT m) where
-    mzero = mempty
-    mplus = mappend
-
-instance Monad m => Alternative (ListT m) where
-    (<|>) = mplus
-    empty = mzero
-
-instance MonadTrans ListT where
-    lift = ListT . liftM (`Cons` mempty)
-
-instance Monad m => List (ListT m) where
-    type ItemM (ListT m) = m
-    runList = runListT
-    joinL = ListT . (>>= runList)
-    cons x = ListT . return . Cons x
-
-instance MonadIO m => MonadIO (ListT m) where
-    liftIO = lift . liftIO
diff --git a/src/Control/Monad/Trans/List/Funcs.hs b/src/Control/Monad/Trans/List/Funcs.hs
deleted file mode 100644
--- a/src/Control/Monad/Trans/List/Funcs.hs
+++ /dev/null
@@ -1,24 +0,0 @@
--- | @List@ functions with type limited to use @ListT@.
--- This might come useful for type interference.
---
--- Functions where the @List@ is an input type and not only the result type do not need special limited versions.
-
-module Control.Monad.Trans.List.Funcs
-    ( iterateM, repeatM, repeat, fromList
-    ) where
-
-import Control.Monad.Trans.List (ListT)
-import qualified Data.List.Class as ListFuncs
-import Prelude hiding (repeat)
-
-iterateM :: Monad m => (a -> m a) -> m a -> ListT m a
-iterateM = ListFuncs.iterateM
-
-repeatM :: Monad m => m a -> ListT m a
-repeatM = ListFuncs.repeatM
-
-repeat :: Monad m => a -> ListT m a
-repeat = ListFuncs.repeat
-
-fromList :: Monad m => [a] -> ListT m a
-fromList = ListFuncs.fromList