Add Alt, Plus, MonadPlus, update Alternative

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": "*"

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
 

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

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)

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)

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

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

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

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

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
 

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

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,17 +29,23 @@ 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
     runReaderT (k a) r
 
 instance monadReaderT :: (Monad m) => Monad (ReaderT r m)
 
+instance monadPlusReaderT :: (MonadPlus m) => MonadPlus (ReaderT r m)
+
 instance monadTransReaderT :: MonadTrans (ReaderT r) where
   lift = liftReaderT
 

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

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

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,17 +33,23 @@ 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
     runStateT (f v) s'
 
 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

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

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

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