Merge pull request #27 from pseudonom/master

Removed `Error e` constraint wherever possible

Author: garyb

docs/Module.md

@@ -212,7 +212,7 @@
 
     instance monadContContT :: (Monad m) => MonadCont (Cont.ContT r m)
 
-    instance monadContErrorT :: (Error e, MonadCont m) => MonadCont (ErrorT e m)
+    instance monadContErrorT :: (MonadCont m) => MonadCont (ErrorT e m)
 
     instance monadContMaybeT :: (MonadCont m) => MonadCont (MaybeT m)
 
@@ -282,9 +282,9 @@
 
 ### Type Class Instances
 
-    instance monadErrorError :: (Error e) => MonadError e (Either e)
+    instance monadErrorError :: MonadError e (Either e)
 
-    instance monadErrorErrorT :: (Monad m, Error e) => MonadError e (ErrorT e m)
+    instance monadErrorErrorT :: (Monad m) => MonadError e (ErrorT e m)
 
     instance monadErrorMaybeT :: (Monad m, MonadError e m) => MonadError e (MaybeT m)
 
@@ -305,23 +305,23 @@
 
 ### Type Class Instances
 
-    instance altErrorT :: (Monad m, Error e) => Alt (ErrorT e m)
+    instance altErrorT :: (Monad m) => Alt (ErrorT e m)
 
     instance alternativeErrorT :: (Monad m, Error e) => Alternative (ErrorT e m)
 
     instance applicativeErrorT :: (Applicative m) => Applicative (ErrorT e m)
 
     instance applyErrorT :: (Apply m) => Apply (ErrorT e m)
 
-    instance bindErrorT :: (Monad m, Error e) => Bind (ErrorT e m)
+    instance bindErrorT :: (Monad m) => Bind (ErrorT e m)
 
     instance functorErrorT :: (Functor m) => Functor (ErrorT e m)
 
-    instance monadErrorT :: (Monad m, Error e) => Monad (ErrorT e m)
+    instance monadErrorT :: (Monad m) => Monad (ErrorT e m)
 
     instance monadPlusErrorT :: (Monad m, Error e) => MonadPlus (ErrorT e m)
 
-    instance monadTransErrorT :: (Error e) => MonadTrans (ErrorT e)
+    instance monadTransErrorT :: MonadTrans (ErrorT e)
 
     instance plusErrorT :: (Monad m, Error e) => Plus (ErrorT e m)
 
@@ -436,7 +436,7 @@
 
 ### Type Class Instances
 
-    instance monadRWSErrorT :: (Monad m, Monoid w, MonadRWS r w s m, MonadReader r m, MonadWriter w m, MonadState s m, Error e) => MonadRWS r w s (ErrorT e m)
+    instance monadRWSErrorT :: (Monad m, Monoid w, MonadRWS r w s m, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (ErrorT e m)
 
     instance monadRWSMaybeT :: (Monad m, Monoid w, MonadRWS r w s m, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (MaybeT m)
 
@@ -510,7 +510,7 @@
 
 ### Type Class Instances
 
-    instance monadReaderErrorT :: (Monad m, Error e, MonadReader r m) => MonadReader r (ErrorT e m)
+    instance monadReaderErrorT :: (Monad m, MonadReader r m) => MonadReader r (ErrorT e m)
 
     instance monadReaderFun :: MonadReader r (Prim.Function r)
 
@@ -606,7 +606,7 @@
 
 ### Type Class Instances
 
-    instance monadStateErrorT :: (Monad m, Error e, MonadState s m) => MonadState s (ErrorT e m)
+    instance monadStateErrorT :: (Monad m, MonadState s m) => MonadState s (ErrorT e m)
 
     instance monadStateMaybeT :: (Monad m, MonadState s m) => MonadState s (MaybeT m)
 
@@ -724,7 +724,7 @@
 
 ### Type Class Instances
 
-    instance monadWriterErrorT :: (Monad m, Error e, MonadWriter w m) => MonadWriter w (ErrorT e m)
+    instance monadWriterErrorT :: (Monad m, MonadWriter w m) => MonadWriter w (ErrorT e m)
 
     instance monadWriterMaybeT :: (Monad m, MonadWriter w m) => MonadWriter w (MaybeT m)
 
@@ -787,4 +787,4 @@
 
     mapWriterT :: forall w1 w2 m1 m2 a b. (m1 (Tuple a w1) -> m2 (Tuple b w2)) -> WriterT w1 m1 a -> WriterT w2 m2 b
 
-    runWriterT :: forall w m a. WriterT w m a -> m (Tuple a w)
+    runWriterT :: forall w m a. WriterT w m a -> m (Tuple a w)

src/Control/Monad/Cont/Class.purs

@@ -16,7 +16,7 @@ class MonadCont m where
 instance monadContContT :: (Monad m) => MonadCont (Cont.ContT r m) where
   callCC = Cont.callCC
 
-instance monadContErrorT :: (Error e, MonadCont m) => MonadCont (ErrorT e m) where
+instance monadContErrorT :: (MonadCont m) => MonadCont (ErrorT e m) where
   callCC = liftCallCCError callCC
 
 instance monadContMaybeT :: (MonadCont m) => MonadCont (MaybeT m) where

src/Control/Monad/Error/Class.purs

@@ -14,12 +14,12 @@ 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
+instance monadErrorError :: MonadError e (Either e) where
   throwError = Left
   catchError (Left e) h = h e
   catchError (Right x) _ = Right x
 
-instance monadErrorErrorT :: (Monad m, Error e) => MonadError e (ErrorT e m) where
+instance monadErrorErrorT :: (Monad m) => MonadError e (ErrorT e m) where
   throwError e = ErrorT $ return (Left e)
   catchError m h = ErrorT $ do
     a <- runErrorT m

src/Control/Monad/Error/Trans.purs

@@ -28,7 +28,7 @@ instance applyErrorT :: (Apply m) => Apply (ErrorT e m) where
 instance applicativeErrorT :: (Applicative m) => Applicative (ErrorT e m) where
   pure a = ErrorT $ pure $ Right a
 
-instance altErrorT :: (Monad m, Error e) => Alt (ErrorT e m) where
+instance altErrorT :: (Monad m) => Alt (ErrorT e m) where
   (<|>) x y = ErrorT $ runErrorT x >>= \e -> case e of
     Left _ -> runErrorT y
     r -> return r
@@ -38,18 +38,18 @@ instance plusErrorT :: (Monad m, Error e) => Plus (ErrorT e m) where
 
 instance alternativeErrorT :: (Monad m, Error e) => Alternative (ErrorT e m)
 
-instance bindErrorT :: (Monad m, Error e) => Bind (ErrorT e m) where
+instance bindErrorT :: (Monad m) => Bind (ErrorT e m) where
   (>>=) m f = ErrorT $ do
     a <- runErrorT m
     case a of
       Left e -> return $ Left e
       Right x -> runErrorT (f x)
 
-instance monadErrorT :: (Monad m, Error e) => Monad (ErrorT e m)
+instance monadErrorT :: (Monad m) => Monad (ErrorT e m)
 
 instance monadPlusErrorT :: (Monad m, Error e) => MonadPlus (ErrorT e m)
 
-instance monadTransErrorT :: (Error e) => MonadTrans (ErrorT e) where
+instance monadTransErrorT :: MonadTrans (ErrorT e) where
   lift m = ErrorT $ do
     a <- m
     return $ Right a

src/Control/Monad/RWS/Class.purs

@@ -13,6 +13,6 @@ class (Monad m, Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) <= M
 
 instance monadRWSRWST :: (Monad m, Monoid w) => MonadRWS r w s (RWST r w s m)
 
-instance monadRWSErrorT :: (Monad m, Monoid w, MonadRWS r w s m, MonadReader r m, MonadWriter w m, MonadState s m, Error e) => MonadRWS r w s (ErrorT e m)
+instance monadRWSErrorT :: (Monad m, Monoid w, MonadRWS r w s m, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (ErrorT e m)
 
 instance monadRWSMaybeT :: (Monad m, Monoid w, MonadRWS r w s m, MonadReader r m, MonadWriter w m, MonadState s m) => MonadRWS r w s (MaybeT m)

src/Control/Monad/Reader/Class.purs

@@ -27,7 +27,7 @@ instance monadReaderReaderT :: (Monad m) => MonadReader r (ReaderT r m) where
   ask = ReaderT return
   local = withReaderT
 
-instance monadReaderErrorT :: (Monad m, Error e, MonadReader r m) => MonadReader r (ErrorT e m) where
+instance monadReaderErrorT :: (Monad m, MonadReader r m) => MonadReader r (ErrorT e m) where
   ask = lift ask
   local f = mapErrorT (local f)
 

src/Control/Monad/State/Class.purs

@@ -34,7 +34,7 @@ instance monadStateStateT :: (Monad m) => MonadState s (StateT s m) where
 instance monadStateStateT1 :: (Monad m, MonadState s m) => MonadState s (StateT s1 m) where
   state f = lift (state f)
 
-instance monadStateErrorT :: (Monad m, Error e, MonadState s m) => MonadState s (ErrorT e m) where
+instance monadStateErrorT :: (Monad m, MonadState s m) => MonadState s (ErrorT e m) where
   state f = lift (state f)
 
 instance monadStateMaybeT :: (Monad m, MonadState s m) => MonadState s (MaybeT m) where

src/Control/Monad/Writer/Class.purs

@@ -40,7 +40,7 @@ instance monadWriterWriterT :: (Monoid w, Monad m) => MonadWriter w (WriterT w m
     Tuple (Tuple a f) w <- runWriterT m
     return $ Tuple a (f w)
 
-instance monadWriterErrorT :: (Monad m, Error e, MonadWriter w m) => MonadWriter w (ErrorT e m) where
+instance monadWriterErrorT :: (Monad m, MonadWriter w m) => MonadWriter w (ErrorT e m) where
   writer wd = lift (writer wd)
   listen = liftListenError listen
   pass = liftPassError pass