diff --git a/bower.json b/bower.json
index dbef20d8..d027b07d 100644
--- a/bower.json
+++ b/bower.json
@@ -21,8 +21,8 @@
     "purescript-tuples": "*",
     "purescript-either": "*",
     "purescript-monoid": "*",
-    "purescript-arrays": "*",
-    "purescript-control": "*"
+    "purescript-arrays": "~0.2.0",
+    "purescript-control": "~0.2.0"
   },
   "devDependencies": {
     "purescript-strings": "*"
diff --git a/docs/Module.md b/docs/Module.md
index 24c7ba36..20c6b8db 100644
--- a/docs/Module.md
+++ b/docs/Module.md
@@ -68,8 +68,12 @@
 
 ### Type Class Instances
 
+    instance errorEitherAlt :: (Error e) => Alt (Either e)
+
     instance errorEitherAlternative :: (Error e) => Alternative (Either e)
 
+    instance errorEitherPlus :: (Error e) => Plus (Either e)
+
     instance errorString :: Error String
 
 
@@ -107,6 +111,8 @@
 
 ### Type Class Instances
 
+    instance altErrorT :: (Monad m, Error e) => Alt (ErrorT e m)
+
     instance alternativeErrorT :: (Monad m, Error e) => Alternative (ErrorT e m)
 
     instance applicativeErrorT :: (Functor m, Monad m) => Applicative (ErrorT e m)
@@ -119,8 +125,12 @@
 
     instance monadErrorT :: (Monad m, Error e) => Monad (ErrorT e m)
 
+    instance monadPlusErrorT :: (Monad m, Error e) => MonadPlus (ErrorT e m)
+
     instance monadTransErrorT :: (Error e) => MonadTrans (ErrorT e)
 
+    instance plusErrorT :: (Monad m, Error e) => Plus (ErrorT e m)
+
 
 ### Values
 
@@ -410,6 +420,8 @@
 
 ### Type Class Instances
 
+    instance altReaderT :: (Alt m) => Alt (ReaderT r m)
+
     instance alternativeReaderT :: (Alternative m) => Alternative (ReaderT r m)
 
     instance applicativeReaderT :: (Applicative m) => Applicative (ReaderT r m)
@@ -420,10 +432,14 @@
 
     instance functorReaderT :: (Functor m) => Functor (ReaderT r m)
 
+    instance monadPlusReaderT :: (MonadPlus m) => MonadPlus (ReaderT r m)
+
     instance monadReaderT :: (Monad m) => Monad (ReaderT r m)
 
     instance monadTransReaderT :: MonadTrans (ReaderT r)
 
+    instance plusReaderT :: (Plus m) => Plus (ReaderT r m)
+
 
 ### Values
 
@@ -506,7 +522,9 @@
 
 ### Type Class Instances
 
-    instance alternativeStateT :: (Alternative m) => Alternative (StateT s m)
+    instance altStateT :: (Monad m, Alt m) => Alt (StateT s m)
+
+    instance alternativeStateT :: (Monad m, Alternative m) => Alternative (StateT s m)
 
     instance applicativeStateT :: (Monad m) => Applicative (StateT s m)
 
@@ -516,10 +534,14 @@
 
     instance functorStateT :: (Monad m) => Functor (StateT s m)
 
+    instance monadPlusStateT :: (MonadPlus m) => MonadPlus (StateT s m)
+
     instance monadStateT :: (Monad m) => Monad (StateT s m)
 
     instance monadTransStateT :: MonadTrans (StateT s)
 
+    instance plusStateT :: (Monad m, Plus m) => Plus (StateT s m)
+
 
 ### Values
 
@@ -642,20 +664,26 @@
 
 ### Type Class Instances
 
+    instance altWriterT :: (Monoid w, Alt m) => Alt (WriterT w m)
+
     instance alternativeWriterT :: (Monoid w, Alternative m) => Alternative (WriterT w m)
 
-    instance applicativeWriterT :: (Monoid w, Functor m, Applicative m) => Applicative (WriterT w m)
+    instance applicativeWriterT :: (Monoid w, Applicative m) => Applicative (WriterT w m)
 
-    instance applyWriterT :: (Monoid w, Functor m, Applicative m) => Apply (WriterT w m)
+    instance applyWriterT :: (Monoid w, Apply m) => Apply (WriterT w m)
 
     instance bindWriterT :: (Monoid w, Monad m) => Bind (WriterT w m)
 
     instance functorWriterT :: (Functor m) => Functor (WriterT w m)
 
+    instance monadPlusWriterT :: (Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
+
     instance monadTransWriterT :: (Monoid w) => MonadTrans (WriterT w)
 
     instance monadWriterT :: (Monoid w, Monad m) => Monad (WriterT w m)
 
+    instance plusWriterT :: (Monoid w, Plus m) => Plus (WriterT w m)
+
 
 ### Values
 
diff --git a/src/Control/Monad/Cont/Class.purs b/src/Control/Monad/Cont/Class.purs
index 6de113b2..2cc9c3ad 100644
--- a/src/Control/Monad/Cont/Class.purs
+++ b/src/Control/Monad/Cont/Class.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Cont.Class where
 
-import Prelude
 import Control.Monad.Error
 import qualified Control.Monad.Cont.Trans as Cont
 import Control.Monad.Error
diff --git a/src/Control/Monad/Cont/Trans.purs b/src/Control/Monad/Cont/Trans.purs
index 2839f5bf..90f4052b 100644
--- a/src/Control/Monad/Cont/Trans.purs
+++ b/src/Control/Monad/Cont/Trans.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Cont.Trans where
 
-import Prelude
 import Control.Monad.Trans
 
 newtype ContT r m a = ContT ((a -> m r) -> m r)
diff --git a/src/Control/Monad/Error.purs b/src/Control/Monad/Error.purs
index aa6adf69..49797ac7 100644
--- a/src/Control/Monad/Error.purs
+++ b/src/Control/Monad/Error.purs
@@ -1,17 +1,23 @@
 module Control.Monad.Error where
 
-import Prelude
+import Control.Alt
+import Control.Alternative
+import Control.Plus
 import Data.Either
 
 class Error a where
   noMsg :: a
   strMsg :: String -> a
-  
+
 instance errorString :: Error String where
   noMsg = ""
   strMsg = id
 
-instance errorEitherAlternative :: (Error e) => Alternative (Either e) where
-  empty = Left noMsg
+instance errorEitherAlt :: (Error e) => Alt (Either e) where
   (<|>) (Left _) n = n
   (<|>) m _ = m
+
+instance errorEitherPlus :: (Error e) => Plus (Either e) where
+  empty = Left noMsg
+
+instance errorEitherAlternative :: (Error e) => Alternative (Either e)
diff --git a/src/Control/Monad/Error/Class.purs b/src/Control/Monad/Error/Class.purs
index 403fbb94..533bac2c 100644
--- a/src/Control/Monad/Error/Class.purs
+++ b/src/Control/Monad/Error/Class.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Error.Class where
 
-import Prelude
 import Control.Monad.Trans
 import Control.Monad.Error
 import Control.Monad.Error.Trans
@@ -14,7 +13,7 @@ import Data.Monoid
 class MonadError e m where
   throwError :: forall a. e -> m a
   catchError :: forall a. m a -> (e -> m a) -> m a
-  
+
 instance monadErrorError :: (Error e) => MonadError e (Either e) where
   throwError = Left
   catchError (Left e) h = h e
diff --git a/src/Control/Monad/Error/Trans.purs b/src/Control/Monad/Error/Trans.purs
index 53c17639..fbb80872 100644
--- a/src/Control/Monad/Error/Trans.purs
+++ b/src/Control/Monad/Error/Trans.purs
@@ -1,8 +1,11 @@
 module Control.Monad.Error.Trans where
 
-import Prelude
+import Control.Alt
+import Control.Alternative
+import Control.Plus
 import Control.Monad.Error
 import Control.Monad.Trans
+import Control.MonadPlus
 import Data.Either
 import Data.Monoid
 import Data.Tuple
@@ -32,12 +35,16 @@ instance applyErrorT :: (Functor m, Monad m) => Apply (ErrorT e m) where
 instance applicativeErrorT :: (Functor m, Monad m) => Applicative (ErrorT e m) where
   pure a = ErrorT $ pure $ Right a
 
-instance alternativeErrorT :: (Monad m, Error e) => Alternative (ErrorT e m) where
-  empty = ErrorT (return (Left $ strMsg "No alternative"))
+instance altErrorT :: (Monad m, Error e) => Alt (ErrorT e m) where
   (<|>) x y = ErrorT $ runErrorT x >>= \e -> case e of
     Left _ -> runErrorT y
     r -> return r
 
+instance plusErrorT :: (Monad m, Error e) => Plus (ErrorT e m) where
+  empty = ErrorT (return (Left $ strMsg "No alternative"))
+
+instance alternativeErrorT :: (Monad m, Error e) => Alternative (ErrorT e m)
+
 instance bindErrorT :: (Monad m, Error e) => Bind (ErrorT e m) where
   (>>=) m f = ErrorT $ do
     a <- runErrorT m
@@ -47,6 +54,8 @@ instance bindErrorT :: (Monad m, Error e) => Bind (ErrorT e m) where
 
 instance monadErrorT :: (Monad m, Error e) => Monad (ErrorT e m)
 
+instance monadPlusErrorT :: (Monad m, Error e) => MonadPlus (ErrorT e m)
+
 instance monadTransErrorT :: (Error e) => MonadTrans (ErrorT e) where
   lift m = ErrorT $ do
     a <- m
diff --git a/src/Control/Monad/Identity.purs b/src/Control/Monad/Identity.purs
index 9d5bad40..3a7f53c6 100644
--- a/src/Control/Monad/Identity.purs
+++ b/src/Control/Monad/Identity.purs
@@ -1,7 +1,5 @@
 module Control.Monad.Identity where
 
-import Prelude
-
 newtype Identity a = Identity a
 
 runIdentity :: forall a. Identity a -> a
diff --git a/src/Control/Monad/Maybe/Trans.purs b/src/Control/Monad/Maybe/Trans.purs
index 7ba9ad0e..2f618390 100644
--- a/src/Control/Monad/Maybe/Trans.purs
+++ b/src/Control/Monad/Maybe/Trans.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Maybe.Trans where
 
-import Prelude
 import Control.Monad
 import Control.Monad.Trans
 import Data.Either
diff --git a/src/Control/Monad/Reader.purs b/src/Control/Monad/Reader.purs
index 2ce7ab0b..82dda44c 100644
--- a/src/Control/Monad/Reader.purs
+++ b/src/Control/Monad/Reader.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Reader where
 
-import Prelude
 import Control.Monad.Identity
 import Control.Monad.Reader.Trans
 
diff --git a/src/Control/Monad/Reader/Class.purs b/src/Control/Monad/Reader/Class.purs
index 99c017d3..86ae75a4 100644
--- a/src/Control/Monad/Reader/Class.purs
+++ b/src/Control/Monad/Reader/Class.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Reader.Class where
 
-import Prelude
 import Control.Monad.Trans
 import Control.Monad.Reader.Trans
 import Control.Monad.Error
diff --git a/src/Control/Monad/Reader/Trans.purs b/src/Control/Monad/Reader/Trans.purs
index e4904852..d43965ef 100644
--- a/src/Control/Monad/Reader/Trans.purs
+++ b/src/Control/Monad/Reader/Trans.purs
@@ -1,7 +1,10 @@
 module Control.Monad.Reader.Trans where
 
-import Prelude
+import Control.Alt
+import Control.Alternative
+import Control.Plus
 import Control.Monad.Trans
+import Control.MonadPlus
 
 newtype ReaderT r m a = ReaderT (r -> m a)
 
@@ -26,10 +29,14 @@ instance applyReaderT :: (Applicative m) => Apply (ReaderT r m) where
 instance applicativeReaderT :: (Applicative m) => Applicative (ReaderT r m) where
   pure = liftReaderT <<< pure
 
-instance alternativeReaderT :: (Alternative m) => Alternative (ReaderT r m) where
-  empty = liftReaderT empty
+instance altReaderT :: (Alt m) => Alt (ReaderT r m) where
   (<|>) m n = ReaderT \r -> runReaderT m r <|> runReaderT n r
 
+instance plusReaderT :: (Plus m) => Plus (ReaderT r m) where
+  empty = liftReaderT empty
+
+instance alternativeReaderT :: (Alternative m) => Alternative (ReaderT r m)
+
 instance bindReaderT :: (Monad m) => Bind (ReaderT r m) where
   (>>=) m k = ReaderT \r -> do
     a <- runReaderT m r
@@ -37,6 +44,8 @@ instance bindReaderT :: (Monad m) => Bind (ReaderT r m) where
 
 instance monadReaderT :: (Monad m) => Monad (ReaderT r m)
 
+instance monadPlusReaderT :: (MonadPlus m) => MonadPlus (ReaderT r m)
+
 instance monadTransReaderT :: MonadTrans (ReaderT r) where
   lift = liftReaderT
 
diff --git a/src/Control/Monad/State.purs b/src/Control/Monad/State.purs
index 5281b90f..bd5e65c9 100644
--- a/src/Control/Monad/State.purs
+++ b/src/Control/Monad/State.purs
@@ -1,6 +1,5 @@
 module Control.Monad.State where
 
-import Prelude
 import Control.Monad.Identity
 import Control.Monad.State.Trans
 import Data.Tuple
diff --git a/src/Control/Monad/State/Class.purs b/src/Control/Monad/State/Class.purs
index 7a871da8..96486028 100644
--- a/src/Control/Monad/State/Class.purs
+++ b/src/Control/Monad/State/Class.purs
@@ -1,6 +1,5 @@
 module Control.Monad.State.Class where
 
-import Prelude
 import Control.Monad.Trans
 import Control.Monad.State.Trans
 import Control.Monad.Error
diff --git a/src/Control/Monad/State/Trans.purs b/src/Control/Monad/State/Trans.purs
index 022dc24f..fa8eadda 100644
--- a/src/Control/Monad/State/Trans.purs
+++ b/src/Control/Monad/State/Trans.purs
@@ -1,7 +1,10 @@
 module Control.Monad.State.Trans where
 
-import Prelude
+import Control.Alt
+import Control.Alternative
+import Control.Plus
 import Control.Monad.Trans
+import Control.MonadPlus
 import Data.Tuple
 
 newtype StateT s m a = StateT (s -> m (Tuple a s))
@@ -30,10 +33,14 @@ instance applyStateT :: (Monad m) => Apply (StateT s m) where
 instance applicativeStateT :: (Monad m) => Applicative (StateT s m) where
   pure a = StateT $ \s -> return $ Tuple a s
 
-instance alternativeStateT :: (Alternative m) => Alternative (StateT s m) where
-  empty = StateT $ \_ -> empty
+instance altStateT :: (Monad m, Alt m) => Alt (StateT s m) where
   (<|>) x y = StateT $ \s -> runStateT x s <|> runStateT y s
 
+instance plusStateT :: (Monad m, Plus m) => Plus (StateT s m) where
+  empty = StateT $ \_ -> empty
+
+instance alternativeStateT :: (Monad m, Alternative m) => Alternative (StateT s m)
+
 instance bindStateT :: (Monad m) => Bind (StateT s m) where
   (>>=) (StateT x) f = StateT \s -> do
     Tuple v s' <- x s
@@ -41,6 +48,8 @@ instance bindStateT :: (Monad m) => Bind (StateT s m) where
 
 instance monadStateT :: (Monad m) => Monad (StateT s m)
 
+instance monadPlusStateT :: (MonadPlus m) => MonadPlus (StateT s m)
+
 instance monadTransStateT :: MonadTrans (StateT s) where
   lift m = StateT \s -> do
     x <- m
diff --git a/src/Control/Monad/Trans.purs b/src/Control/Monad/Trans.purs
index cd701a7b..18238a44 100644
--- a/src/Control/Monad/Trans.purs
+++ b/src/Control/Monad/Trans.purs
@@ -1,6 +1,4 @@
 module Control.Monad.Trans where
 
-import Prelude
-
 class MonadTrans t where
   lift :: forall m a. (Monad m) => m a -> t m a
diff --git a/src/Control/Monad/Writer.purs b/src/Control/Monad/Writer.purs
index c747de9e..34632adb 100644
--- a/src/Control/Monad/Writer.purs
+++ b/src/Control/Monad/Writer.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Writer where
 
-import Prelude
 import Control.Monad.Identity
 import Control.Monad.Writer.Trans
 import Data.Monoid
diff --git a/src/Control/Monad/Writer/Class.purs b/src/Control/Monad/Writer/Class.purs
index ca4c40a1..a6cd90f8 100644
--- a/src/Control/Monad/Writer/Class.purs
+++ b/src/Control/Monad/Writer/Class.purs
@@ -1,6 +1,5 @@
 module Control.Monad.Writer.Class where
 
-import Prelude
 import Control.Monad.Trans
 import Control.Monad.Writer.Trans
 import Control.Monad.Error
diff --git a/src/Control/Monad/Writer/Trans.purs b/src/Control/Monad/Writer/Trans.purs
index 4b3f4dd8..1a8d2f88 100644
--- a/src/Control/Monad/Writer/Trans.purs
+++ b/src/Control/Monad/Writer/Trans.purs
@@ -1,7 +1,10 @@
 module Control.Monad.Writer.Trans where
 
-import Prelude
+import Control.Alt
+import Control.Alternative
+import Control.Plus
 import Control.Monad.Trans
+import Control.MonadPlus
 import Data.Monoid
 import Data.Tuple
 
@@ -16,18 +19,22 @@ mapWriterT f m = WriterT $ f (runWriterT m)
 instance functorWriterT :: (Functor m) => Functor (WriterT w m) where
   (<$>) f = mapWriterT $ (<$>) \(Tuple a w) -> Tuple (f a) w
 
-instance applyWriterT :: (Monoid w, Functor m, Applicative m) => Apply (WriterT w m) where
+instance applyWriterT :: (Monoid w, Apply m) => Apply (WriterT w m) where
   (<*>) f v = WriterT $
     let k (Tuple a w) (Tuple b w') = Tuple (a b) (w <> w')
     in k <$> (runWriterT f) <*> (runWriterT v)
 
-instance applicativeWriterT :: (Monoid w, Functor m, Applicative m) => Applicative (WriterT w m) where
+instance applicativeWriterT :: (Monoid w, Applicative m) => Applicative (WriterT w m) where
   pure a = WriterT $ pure $ Tuple a mempty
 
-instance alternativeWriterT :: (Monoid w, Alternative m) => Alternative (WriterT w m) where
-  empty = WriterT empty
+instance altWriterT :: (Monoid w, Alt m) => Alt (WriterT w m) where
   (<|>) m n = WriterT $ runWriterT m <|> runWriterT n
 
+instance plusWriterT :: (Monoid w, Plus m) => Plus (WriterT w m) where
+  empty = WriterT empty
+
+instance alternativeWriterT :: (Monoid w, Alternative m) => Alternative (WriterT w m)
+
 instance bindWriterT :: (Monoid w, Monad m) => Bind (WriterT w m) where
   (>>=) m k  = WriterT $ do
     Tuple a w <- runWriterT m
@@ -36,6 +43,8 @@ instance bindWriterT :: (Monoid w, Monad m) => Bind (WriterT w m) where
 
 instance monadWriterT :: (Monoid w, Monad m) => Monad (WriterT w m)
 
+instance monadPlusWriterT :: (Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
+
 instance monadTransWriterT :: (Monoid w) => MonadTrans (WriterT w) where
   lift m = WriterT $ do
     a <- m