diff --git a/Control/Monad/Trans/Accum.hs b/Control/Monad/Trans/Accum.hs
index bd34a30..dd901c3 100644
--- a/Control/Monad/Trans/Accum.hs
+++ b/Control/Monad/Trans/Accum.hs
@@ -190,10 +190,10 @@ instance (Monoid w, Monad m) => Applicative (AccumT w m) where
       return (f v, w' `mappend` w'')
     {-# INLINE (<*>) #-}
 
-instance (Monoid w, MonadPlus m) => Alternative (AccumT w m) where
-    empty   = AccumT $ const mzero
+instance (Monoid w, Alternative m, Monad m) => Alternative (AccumT w m) where
+    empty   = AccumT $ const empty
     {-# INLINE empty #-}
-    m <|> n = AccumT $ \ w -> runAccumT m w `mplus` runAccumT n w
+    m <|> n = AccumT $ \ w -> runAccumT m w <|> runAccumT n w
     {-# INLINE (<|>) #-}
 
 instance (Monoid w, Monad m) => Monad (AccumT w m) where
diff --git a/Control/Monad/Trans/Except.hs b/Control/Monad/Trans/Except.hs
index 8af6f3a..b131367 100644
--- a/Control/Monad/Trans/Except.hs
+++ b/Control/Monad/Trans/Except.hs
@@ -59,8 +59,6 @@ import Control.Monad
 import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix
 import Control.Monad.Zip (MonadZip(mzipWith))
-import Data.Foldable (Foldable(foldMap))
-import Data.Traversable (Traversable(traverse))
 #ifdef __GLASGOW_HASKELL__
 import GHC.Generics
 #endif
diff --git a/Control/Monad/Trans/Identity.hs b/Control/Monad/Trans/Identity.hs
index 2bbe3f0..71ac74b 100644
--- a/Control/Monad/Trans/Identity.hs
+++ b/Control/Monad/Trans/Identity.hs
@@ -41,7 +41,6 @@ import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix (MonadFix(mfix))
 import Control.Monad.Zip (MonadZip(mzipWith))
 import Data.Foldable
-import Data.Traversable (Traversable(traverse))
 import Prelude hiding (foldr, foldr1, foldl, foldl1, null, length)
 #ifdef __GLASGOW_HASKELL__
 import GHC.Generics
diff --git a/Control/Monad/Trans/Maybe.hs b/Control/Monad/Trans/Maybe.hs
index aa1bc13..352f380 100644
--- a/Control/Monad/Trans/Maybe.hs
+++ b/Control/Monad/Trans/Maybe.hs
@@ -50,8 +50,6 @@ import qualified Control.Monad.Fail as Fail
 import Control.Monad.Fix (MonadFix(mfix))
 import Control.Monad.Zip (MonadZip(mzipWith))
 import Data.Maybe (fromMaybe)
-import Data.Foldable (Foldable(foldMap))
-import Data.Traversable (Traversable(traverse))
 #ifdef __GLASGOW_HASKELL__
 import GHC.Generics
 #endif
diff --git a/Control/Monad/Trans/RWS/CPS.hs b/Control/Monad/Trans/RWS/CPS.hs
index 915c024..3bba6da 100644
--- a/Control/Monad/Trans/RWS/CPS.hs
+++ b/Control/Monad/Trans/RWS/CPS.hs
@@ -213,11 +213,11 @@ instance (Monad m) => Applicative (RWST r w s m) where
         return (f x, s'', w'')
     {-# INLINE (<*>) #-}
 
-instance (MonadPlus m) => Alternative (RWST r w s m) where
-    empty = RWST $ \ _ _ _ -> mzero
+instance (Alternative m, Monad m) => Alternative (RWST r w s m) where
+    empty = RWST $ \ _ _ _ -> empty
     {-# INLINE empty #-}
 
-    RWST m <|> RWST n = RWST $ \ r s w -> m r s w `mplus` n r s w
+    RWST m <|> RWST n = RWST $ \ r s w -> m r s w <|> n r s w
     {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (RWST r w s m) where
diff --git a/Control/Monad/Trans/RWS/Lazy.hs b/Control/Monad/Trans/RWS/Lazy.hs
index 00819aa..7b8999f 100644
--- a/Control/Monad/Trans/RWS/Lazy.hs
+++ b/Control/Monad/Trans/RWS/Lazy.hs
@@ -187,10 +187,10 @@ instance (Monoid w, Monad m) => Applicative (RWST r w s m) where
         return (f x, s'', w `mappend` w')
     {-# INLINE (<*>) #-}
 
-instance (Monoid w, MonadPlus m) => Alternative (RWST r w s m) where
-    empty = RWST $ \ _ _ -> mzero
+instance (Monoid w, Alternative m, Monad m) => Alternative (RWST r w s m) where
+    empty = RWST $ \ _ _ -> empty
     {-# INLINE empty #-}
-    RWST m <|> RWST n = RWST $ \ r s -> m r s `mplus` n r s
+    RWST m <|> RWST n = RWST $ \ r s -> m r s <|> n r s
     {-# INLINE (<|>) #-}
 
 instance (Monoid w, Monad m) => Monad (RWST r w s m) where
diff --git a/Control/Monad/Trans/RWS/Strict.hs b/Control/Monad/Trans/RWS/Strict.hs
index 10467dc..35aa071 100644
--- a/Control/Monad/Trans/RWS/Strict.hs
+++ b/Control/Monad/Trans/RWS/Strict.hs
@@ -191,10 +191,10 @@ instance (Monoid w, Monad m) => Applicative (RWST r w s m) where
         return (f x, s'', w `mappend` w')
     {-# INLINE (<*>) #-}
 
-instance (Monoid w, MonadPlus m) => Alternative (RWST r w s m) where
-    empty = RWST $ \ _ _ -> mzero
+instance (Monoid w, Alternative m, Monad m) => Alternative (RWST r w s m) where
+    empty = RWST $ \ _ _ -> empty
     {-# INLINE empty #-}
-    RWST m <|> RWST n = RWST $ \ r s -> m r s `mplus` n r s
+    RWST m <|> RWST n = RWST $ \ r s -> m r s <|> n r s
     {-# INLINE (<|>) #-}
 
 instance (Monoid w, Monad m) => Monad (RWST r w s m) where
diff --git a/Control/Monad/Trans/Select.hs b/Control/Monad/Trans/Select.hs
index 7c88b03..d24f62d 100644
--- a/Control/Monad/Trans/Select.hs
+++ b/Control/Monad/Trans/Select.hs
@@ -108,10 +108,10 @@ instance (Monad m) => Applicative (SelectT r m) where
     m *> k = m >>= \_ -> k
     {-# INLINE (*>) #-}
 
-instance (MonadPlus m) => Alternative (SelectT r m) where
-    empty = mzero
+instance (Alternative m, Monad m) => Alternative (SelectT r m) where
+    empty = empty
     {-# INLINE empty #-}
-    (<|>) = mplus
+    (<|>) = (<|>)
     {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (SelectT r m) where
diff --git a/Control/Monad/Trans/State/Lazy.hs b/Control/Monad/Trans/State/Lazy.hs
index f60bcc0..775e1b4 100644
--- a/Control/Monad/Trans/State/Lazy.hs
+++ b/Control/Monad/Trans/State/Lazy.hs
@@ -215,10 +215,10 @@ instance (Monad m) => Applicative (StateT s m) where
     m *> k = m >>= \_ -> k
     {-# INLINE (*>) #-}
 
-instance (MonadPlus m) => Alternative (StateT s m) where
-    empty = StateT $ \ _ -> mzero
+instance (Alternative m, Monad m) => Alternative (StateT s m) where
+    empty = StateT $ \ _ -> empty
     {-# INLINE empty #-}
-    StateT m <|> StateT n = StateT $ \ s -> m s `mplus` n s
+    StateT m <|> StateT n = StateT $ \ s -> m s <|> n s
     {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (StateT s m) where
diff --git a/Control/Monad/Trans/State/Strict.hs b/Control/Monad/Trans/State/Strict.hs
index 0f1f934..7ba4d75 100644
--- a/Control/Monad/Trans/State/Strict.hs
+++ b/Control/Monad/Trans/State/Strict.hs
@@ -208,10 +208,10 @@ instance (Monad m) => Applicative (StateT s m) where
     m *> k = m >>= \_ -> k
     {-# INLINE (*>) #-}
 
-instance (MonadPlus m) => Alternative (StateT s m) where
-    empty = StateT $ \ _ -> mzero
+instance (Alternative m, Monad m) => Alternative (StateT s m) where
+    empty = StateT $ \ _ -> empty
     {-# INLINE empty #-}
-    StateT m <|> StateT n = StateT $ \ s -> m s `mplus` n s
+    StateT m <|> StateT n = StateT $ \ s -> m s <|> n s
     {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (StateT s m) where
diff --git a/Control/Monad/Trans/Writer/CPS.hs b/Control/Monad/Trans/Writer/CPS.hs
index 983ebbe..3faf13b 100644
--- a/Control/Monad/Trans/Writer/CPS.hs
+++ b/Control/Monad/Trans/Writer/CPS.hs
@@ -168,11 +168,11 @@ instance (Monad m) => Applicative (WriterT w m) where
         return (f x, w'')
     {-# INLINE (<*>) #-}
 
-instance (MonadPlus m) => Alternative (WriterT w m) where
-    empty = WriterT $ const mzero
+instance (Alternative m, Monad m) => Alternative (WriterT w m) where
+    empty = WriterT $ const empty
     {-# INLINE empty #-}
 
-    WriterT m <|> WriterT n = WriterT $ \ w -> m w `mplus` n w
+    WriterT m <|> WriterT n = WriterT $ \ w -> m w <|> n w
     {-# INLINE (<|>) #-}
 
 instance (Monad m) => Monad (WriterT w m) where
diff --git a/Control/Monad/Trans/Writer/Lazy.hs b/Control/Monad/Trans/Writer/Lazy.hs
index 4e4f4ac..10297ba 100644
--- a/Control/Monad/Trans/Writer/Lazy.hs
+++ b/Control/Monad/Trans/Writer/Lazy.hs
@@ -58,7 +58,6 @@ import Control.Monad.Fix
 import Control.Monad.Signatures
 import Control.Monad.Zip (MonadZip(mzipWith))
 import Data.Foldable
-import Data.Traversable (Traversable(traverse))
 import Prelude hiding (null, length)
 #ifdef __GLASGOW_HASKELL__
 import GHC.Generics
diff --git a/Control/Monad/Trans/Writer/Strict.hs b/Control/Monad/Trans/Writer/Strict.hs
index 9341496..c575e39 100644
--- a/Control/Monad/Trans/Writer/Strict.hs
+++ b/Control/Monad/Trans/Writer/Strict.hs
@@ -61,7 +61,6 @@ import Control.Monad.Fix
 import Control.Monad.Signatures
 import Control.Monad.Zip (MonadZip(mzipWith))
 import Data.Foldable
-import Data.Traversable (Traversable(traverse))
 import Prelude hiding (null, length)
 #ifdef __GLASGOW_HASKELL__
 import GHC.Generics
diff --git a/Data/Functor/Reverse.hs b/Data/Functor/Reverse.hs
index 1fc5b28..c3e5f66 100644
--- a/Data/Functor/Reverse.hs
+++ b/Data/Functor/Reverse.hs
@@ -32,7 +32,6 @@ import Control.Applicative
 import Control.Monad
 import qualified Control.Monad.Fail as Fail
 import Data.Foldable
-import Data.Traversable (Traversable(traverse))
 import Data.Monoid (Dual (..))
 #ifdef __GLASGOW_HASKELL__
 import GHC.Generics