Merge no-t1 branch

Author: paf31

docs/Control/Monad/Cont/Class.md

@@ -5,24 +5,23 @@ This module defines the `MonadCont` type class and its instances.
 #### `MonadCont`
 
 ``` purescript
-class MonadCont m where
+class (Monad m) <= MonadCont m where
   callCC :: forall a b. ((a -> m b) -> m a) -> m a
 ```
 
 The `MonadCont` type class represents those monads which support the
-`callCC` operation.
+`callCC`, or _call-with-current-continuation_ operation.
 
-An implementation is provided for `ContT`, and for other monad transformers
-defined in this library.
+This action makes the current continuation available to the caller.
 
-##### Instances
-``` purescript
-instance monadContContT :: (Monad m) => MonadCont (ContT r m)
-instance monadContErrorT :: (MonadCont m) => MonadCont (ErrorT e m)
-instance monadContMaybeT :: (MonadCont m) => MonadCont (MaybeT m)
-instance monadContReaderT :: (MonadCont m) => MonadCont (ReaderT r m)
-instance monadContStateT :: (MonadCont m) => MonadCont (StateT s m)
-instance monadWriterT :: (Monoid w, MonadCont m) => MonadCont (WriterT w m)
+For example:
+
+```purescript
+delay :: forall eff. Number -> ContT Unit (Eff (timeout :: Timeout | eff)) Unit
+delay n = callCC \cont ->
+  lift $ setTimeout n (runContT (cont unit) (\_ -> return unit))
 ```
+An implementation is provided for `ContT`, and for other monad transformers
+defined in this library.
 
 

docs/Control/Monad/Cont/Trans.md

@@ -15,13 +15,16 @@ This monad transformer extends the base monad with the operation `callCC`.
 
 ##### Instances
 ``` purescript
+instance monadContContT :: (Monad m) => MonadCont (ContT r m)
 instance functorContT :: (Monad m) => Functor (ContT r m)
-instance applyContT :: (Functor m, Monad m) => Apply (ContT r m)
-instance applicativeContT :: (Functor m, Monad m) => Applicative (ContT r m)
+instance applyContT :: (Monad m) => Apply (ContT r m)
+instance applicativeContT :: (Monad m) => Applicative (ContT r m)
 instance bindContT :: (Monad m) => Bind (ContT r m)
 instance monadContT :: (Monad m) => Monad (ContT r m)
 instance monadTransContT :: MonadTrans (ContT r)
-instance monadEffContT :: (Monad m, MonadEff eff m) => MonadEff eff (ContT r m)
+instance monadEffContT :: (MonadEff eff m) => MonadEff eff (ContT r m)
+instance monadReaderContT :: (MonadReader r1 m) => MonadReader r1 (ContT r m)
+instance monadStateContT :: (MonadState s m) => MonadState s (ContT r m)
 ```
 
 #### `runContT`
@@ -48,22 +51,4 @@ withContT :: forall r m a b. ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r
 
 Modify the continuation in a `ContT` monad action
 
-#### `callCC`
-
-``` purescript
-callCC :: forall r m a b. ((a -> ContT r m b) -> ContT r m a) -> ContT r m a
-```
-
-`callCC`, or _call-with-current-continuation_.
-
-This action makes the current continuation available to the caller.
-
-For example:
-
-```purescript
-delay :: forall eff. Number -> ContT Unit (Eff (timeout :: Timeout | eff)) Unit
-delay n = callCC \cont ->
-  lift $ setTimeout n (runContT (cont unit) (\_ -> return unit))
-```
-
 

docs/Control/Monad/Error/Class.md

@@ -5,7 +5,7 @@ This module defines the `MonadError` type class and its instances.
 #### `MonadError`
 
 ``` purescript
-class MonadError e m where
+class (Monad m) <= MonadError e m where
   throwError :: forall a. e -> m a
   catchError :: forall a. m a -> (e -> m a) -> m a
 ```
@@ -31,12 +31,6 @@ Laws:
 ``` purescript
 instance monadErrorEither :: MonadError e (Either e)
 instance monadErrorMaybe :: MonadError Unit Maybe
-instance monadErrorErrorT :: (Monad m) => MonadError e (ErrorT e m)
-instance monadErrorExceptT :: (Monad m) => MonadError e (ExceptT e m)
-instance monadErrorMaybeT :: (Monad m, MonadError e m) => MonadError e (MaybeT m)
-instance monadErrorReaderT :: (Monad m, MonadError e m) => MonadError e (ReaderT r m)
-instance monadErrorWriterT :: (Monad m, Monoid w, MonadError e m) => MonadError e (WriterT w m)
-instance monadErrorStateT :: (Monad m, MonadError e m) => MonadError e (StateT s m)
 ```
 
 #### `catchJust`

docs/Control/Monad/Except.md

@@ -7,8 +7,8 @@ type Except e a = ExceptT e Identity a
 ```
 
 A parametrizable exception monad; computations are either exceptions or
-pure values. If an exception is thrown (see `throwE`), the computation
-terminates with that value. Exceptions may also be caught with `catchE`,
+pure values. If an exception is thrown (see `throwError`), the computation
+terminates with that value. Exceptions may also be caught with `catchError`,
 allowing the computation to resume and exit successfully.
 
 The type parameter `e` is the type of exceptions, and `a` is the type

docs/Control/Monad/Except/Trans.md

@@ -1,5 +1,7 @@
 ## Module Control.Monad.Except.Trans
 
+This module defines the _exception monad transformer_ `ExceptT`.
+
 #### `ExceptT`
 
 ``` purescript
@@ -19,13 +21,19 @@ instance applyExceptT :: (Apply m) => Apply (ExceptT e m)
 instance applicativeExceptT :: (Applicative m) => Applicative (ExceptT e m)
 instance bindExceptT :: (Monad m) => Bind (ExceptT e m)
 instance monadExceptT :: (Monad m) => Monad (ExceptT e m)
-instance monadRecErrorT :: (Semigroup e, MonadRec m) => MonadRec (ExceptT e m)
+instance monadRecExceptT :: (MonadRec m) => MonadRec (ExceptT e m)
 instance altExceptT :: (Semigroup e, Monad m) => Alt (ExceptT e m)
 instance plusExceptT :: (Monoid e, Monad m) => Plus (ExceptT e m)
 instance alternativeExceptT :: (Monoid e, Monad m) => Alternative (ExceptT e m)
 instance monadPlusExceptT :: (Monoid e, Monad m) => MonadPlus (ExceptT e m)
 instance monadTransExceptT :: MonadTrans (ExceptT e)
-instance monadEffExceptT :: (Monad m, MonadEff eff m) => MonadEff eff (ExceptT e m)
+instance monadEffExceptT :: (MonadEff eff m) => MonadEff eff (ExceptT e m)
+instance monadContExceptT :: (MonadCont m) => MonadCont (ExceptT e m)
+instance monadErrorExceptT :: (Monad m) => MonadError e (ExceptT e m)
+instance monadReaderExceptT :: (MonadReader r m) => MonadReader r (ExceptT e m)
+instance monadStateExceptT :: (MonadState s m) => MonadState s (ExceptT e m)
+instance monadWriterExceptT :: (MonadWriter w m) => MonadWriter w (ExceptT e m)
+instance monadRWSExceptT :: (Monoid w, MonadRWS r w s m) => MonadRWS r w s (ExceptT e m)
 ```
 
 #### `runExceptT`
@@ -52,20 +60,4 @@ mapExceptT :: forall e e' m n a b. (m (Either e a) -> n (Either e' b)) -> Except
 
 Transform the unwrapped computation using the given function.
 
-#### `throwE`
-
-``` purescript
-throwE :: forall e m a. (Applicative m) => e -> ExceptT e m a
-```
-
-Throw an exception in an `ExceptT` computation.
-
-#### `catchE`
-
-``` purescript
-catchE :: forall e e' m a. (Monad m) => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
-```
-
-Catch an exception in an `ExceptT` computation.
-
 

docs/Control/Monad/List/Trans.md

@@ -29,7 +29,7 @@ instance altListT :: (Applicative f) => Alt (ListT f)
 instance plusListT :: (Monad f) => Plus (ListT f)
 instance alternativeListT :: (Monad f) => Alternative (ListT f)
 instance monadPlusListT :: (Monad f) => MonadPlus (ListT f)
-instance monadEffListT :: (Monad m, MonadEff eff m) => MonadEff eff (ListT m)
+instance monadEffListT :: (MonadEff eff m) => MonadEff eff (ListT m)
 ```
 
 #### `nil`

docs/Control/Monad/Maybe/Trans.md

@@ -27,7 +27,13 @@ instance plusMaybeT :: (Monad m) => Plus (MaybeT m)
 instance alternativeMaybeT :: (Monad m) => Alternative (MaybeT m)
 instance monadPlusMaybeT :: (Monad m) => MonadPlus (MaybeT m)
 instance monadRecMaybeT :: (MonadRec m) => MonadRec (MaybeT m)
-instance monadEffMaybe :: (Monad m, MonadEff eff m) => MonadEff eff (MaybeT m)
+instance monadEffMaybe :: (MonadEff eff m) => MonadEff eff (MaybeT m)
+instance monadContMaybeT :: (MonadCont m) => MonadCont (MaybeT m)
+instance monadErrorMaybeT :: (MonadError e m) => MonadError e (MaybeT m)
+instance monadReaderMaybeT :: (MonadReader r m) => MonadReader r (MaybeT m)
+instance monadStateMaybeT :: (MonadState s m) => MonadState s (MaybeT m)
+instance monadWriterMaybeT :: (Monad m, MonadWriter w m) => MonadWriter w (MaybeT m)
+instance monadRWSMaybeT :: (Monoid w, MonadRWS r w s m) => MonadRWS r w s (MaybeT m)
 ```
 
 #### `runMaybeT`
@@ -46,28 +52,4 @@ mapMaybeT :: forall m1 m2 a b. (m1 (Maybe a) -> m2 (Maybe b)) -> MaybeT m1 a ->
 
 Change the result type of a `MaybeT` monad action.
 
-#### `liftCatchMaybe`
-
-``` purescript
-liftCatchMaybe :: forall m e a. (m (Maybe a) -> (e -> m (Maybe a)) -> m (Maybe a)) -> MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a
-```
-
-#### `liftListenMaybe`
-
-``` purescript
-liftListenMaybe :: forall m a w. (Monad m) => (m (Maybe a) -> m (Tuple (Maybe a) w)) -> MaybeT m a -> MaybeT m (Tuple a w)
-```
-
-#### `liftPassMaybe`
-
-``` purescript
-liftPassMaybe :: forall m a w. (Monad m) => (m (Tuple (Maybe a) (w -> w)) -> m (Maybe a)) -> MaybeT m (Tuple a (w -> w)) -> MaybeT m a
-```
-
-#### `liftCallCCMaybe`
-
-``` purescript
-liftCallCCMaybe :: forall m a b. (((Maybe a -> m (Maybe b)) -> m (Maybe a)) -> m (Maybe a)) -> ((a -> MaybeT m b) -> MaybeT m a) -> MaybeT m a
-```
-
 

docs/Control/Monad/RWS.md

@@ -17,7 +17,7 @@ to the `Identity` monad.
 rws :: forall r w s a. (r -> s -> See s a w) -> RWS r w s a
 ```
 
-Create an action in the `RWS` monad from a function which uses the 
+Create an action in the `RWS` monad from a function which uses the
 global context and state explicitly.
 
 #### `runRWS`
@@ -60,116 +60,4 @@ withRWS :: forall r1 r2 w s a. (r2 -> s -> Tuple r1 s) -> RWS r1 w s a -> RWS r2
 
 Change the type of the context in a `RWS` action
 
-#### `ask`
-
-``` purescript
-ask :: forall r w s m. (Applicative m, Monoid w) => RWST r w s m r
-```
-
-Get the context of a `RWS` action
-
-#### `local`
-
-``` purescript
-local :: forall r w s m a. (r -> r) -> RWST r w s m a -> RWST r w s m a
-```
-
-Locally change the context of a `RWS` action.
-
-#### `reader`
-
-``` purescript
-reader :: forall r w s m a. (Applicative m, Monoid w) => (r -> a) -> RWST r w s m a
-```
-
-Read a value which depends on the context in a `RWS` action.
-
-#### `writer`
-
-``` purescript
-writer :: forall r w s m a. (Applicative m) => Tuple a w -> RWST r w s m a
-```
-
-Write to the accumulator in a `RWS` action
-
-#### `listen`
-
-``` purescript
-listen :: forall r w s m a. (Monad m) => RWST r w s m a -> RWST r w s m (Tuple a w)
-```
-
-Execute a `RWS` action, and return the changes to the accumulator along with the return value
-
-#### `pass`
-
-``` purescript
-pass :: forall r w s m a. (Monad m) => RWST r w s m (Tuple a (w -> w)) -> RWST r w s m a
-```
-
-Execute a `RWS` action and modify the accumulator
-
-#### `tell`
-
-``` purescript
-tell :: forall r w s m. (Applicative m) => w -> RWST r w s m Unit
-```
-
-Append a value to the accumulator in a `RWS` action
-
-#### `listens`
-
-``` purescript
-listens :: forall r w s m a b. (Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (Tuple a b)
-```
-
-Execute a `RWS` action, and return a value which depends on the accumulator along with the return value
-
-#### `censor`
-
-``` purescript
-censor :: forall r w s m a. (Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a
-```
-
-Modify the accumulator in a `RWS` action
-
-#### `state`
-
-``` purescript
-state :: forall r w s m a. (Applicative m, Monoid w) => (s -> Tuple a s) -> RWST r w s m a
-```
-
-Get or modify the state in a `RWS` action
-
-#### `get`
-
-``` purescript
-get :: forall r w s m. (Applicative m, Monoid w) => RWST r w s m s
-```
-
-Get the state in a `RWS` action
-
-#### `gets`
-
-``` purescript
-gets :: forall r w s m a. (Applicative m, Monoid w) => (s -> a) -> RWST r w s m a
-```
-
-Get a value which depends on the state in a `RWS` action
-
-#### `put`
-
-``` purescript
-put :: forall r w s m. (Applicative m, Monoid w) => s -> RWST r w s m Unit
-```
-
-Set the state in a `RWS` action
-
-#### `modify`
-
-``` purescript
-modify :: forall r w s m. (Applicative m, Monoid w) => (s -> s) -> RWST r w s m Unit
-```
-
-Modify the state in a `RWS` action
-
 

docs/Control/Monad/RWS/Class.md

@@ -5,7 +5,7 @@ This module defines the `MonadRWS` type class and its instances.
 #### `MonadRWS`
 
 ``` purescript
-class (Monad m, Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) <= MonadRWS r w s m
+class (Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) <= MonadRWS r w s m
 ```
 
 `MonadRWS r w s` combines the operations and laws of the `MonadReader r`, 
@@ -14,11 +14,4 @@ class (Monad m, Monoid w, MonadReader r m, MonadWriter w m, MonadState s m) <= M
 An implementation is provided for `RWST`, and for other monad transformers
 defined in this library.
 
-##### Instances
-``` purescript
-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) => 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)
-```
-
 

docs/Control/Monad/RWS/Trans.md

@@ -33,6 +33,10 @@ instance applicativeRWST :: (Monad m, Monoid w) => Applicative (RWST r w s m)
 instance monadRWST :: (Monad m, Monoid w) => Monad (RWST r w s m)
 instance monadTransRWST :: (Monoid w) => MonadTrans (RWST r w s)
 instance monadEffRWS :: (Monad m, Monoid w, MonadEff eff m) => MonadEff eff (RWST r w s m)
+instance monadReaderRWST :: (Monad m, Monoid w) => MonadReader r (RWST r w s m)
+instance monadStateRWST :: (Monad m, Monoid w) => MonadState s (RWST r w s m)
+instance monadWriterRWST :: (Monad m, Monoid w) => MonadWriter w (RWST r w s m)
+instance monadRWSRWST :: (Monad m, Monoid w) => MonadRWS r w s (RWST r w s m)
 ```
 
 #### `runRWST`