Fix Cont/Trans docs and rebuild for MonadEff instances

Author: garyb

docs/Control.Monad.Cont.md

@@ -26,3 +26,72 @@ instance monadWriterT :: (Monoid w, MonadCont m) => MonadCont (WriterT w m)
 ```
 
 
+## Module Control.Monad.Cont.Trans
+
+This module defines the CPS monad transformer.
+
+#### `ContT`
+
+``` purescript
+newtype ContT r m a
+  = ContT ((a -> m r) -> m r)
+```
+
+The CPS monad transformer.
+
+This monad transformer extends the base monad with the operation `callCC`.
+
+##### Instances
+``` purescript
+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 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)
+```
+
+#### `runContT`
+
+``` purescript
+runContT :: forall r m a. ContT r m a -> (a -> m r) -> m r
+```
+
+Run a computation in the `ContT` monad, by providing a continuation.
+
+#### `mapContT`
+
+``` purescript
+mapContT :: forall r m a. (m r -> m r) -> ContT r m a -> ContT r m a
+```
+
+Modify the underlying action in a `ContT` monad action.
+
+#### `withContT`
+
+``` purescript
+withContT :: forall r m a b. ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b
+```
+
+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.md

@@ -104,6 +104,7 @@ instance monadErrorT :: (Monad m) => Monad (ErrorT e m)
 instance monadRecErrorT :: (Error e, MonadRec m) => MonadRec (ErrorT e m)
 instance monadPlusErrorT :: (Monad m, Error e) => MonadPlus (ErrorT e m)
 instance monadTransErrorT :: MonadTrans (ErrorT e)
+instance monadEffError :: (Monad m, MonadEff eff m) => MonadEff eff (ErrorT e m)
 ```
 
 #### `runErrorT`

docs/Control.Monad.Except.md

@@ -81,6 +81,8 @@ 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)
 ```
 
 #### `runExceptT`

docs/Control.Monad.List.Trans.md

@@ -29,6 +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)
 ```
 
 #### `nil`

docs/Control.Monad.Maybe.Trans.md

@@ -27,6 +27,7 @@ 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)
 ```
 
 #### `runMaybeT`

docs/Control.Monad.RWS.md

@@ -231,6 +231,7 @@ instance bindRWST :: (Bind m, Monoid w) => Bind (RWST r w s m)
 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)
 ```
 
 #### `runRWST`

docs/Control.Monad.Reader.md

@@ -114,6 +114,7 @@ instance bindReaderT :: (Monad m) => Bind (ReaderT r m)
 instance monadReaderT :: (Monad m) => Monad (ReaderT r m)
 instance monadPlusReaderT :: (MonadPlus m) => MonadPlus (ReaderT r m)
 instance monadTransReaderT :: MonadTrans (ReaderT r)
+instance monadEffReader :: (Monad m, MonadEff eff m) => MonadEff eff (ReaderT r m)
 ```
 
 #### `runReaderT`

docs/Control.Monad.State.md

@@ -155,6 +155,7 @@ instance monadRecStateT :: (MonadRec m) => MonadRec (StateT s m)
 instance monadPlusStateT :: (MonadPlus m) => MonadPlus (StateT s m)
 instance monadTransStateT :: MonadTrans (StateT s)
 instance lazyStateT :: Lazy (StateT s m a)
+instance monadEffState :: (Monad m, MonadEff eff m) => MonadEff eff (StateT s m)
 ```
 
 #### `runStateT`

docs/Control.Monad.Trans.md

@@ -1,71 +1,3 @@
-## Module Control.Monad.Cont.Trans
-
-This module defines the CPS monad transformer.
-
-#### `ContT`
-
-``` purescript
-newtype ContT r m a
-  = ContT ((a -> m r) -> m r)
-```
-
-The CPS monad transformer.
-
-This monad transformer extends the base monad with the operation `callCC`.
-
-##### Instances
-``` purescript
-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 bindContT :: (Monad m) => Bind (ContT r m)
-instance monadContT :: (Monad m) => Monad (ContT r m)
-instance monadTransContT :: MonadTrans (ContT r)
-```
-
-#### `runContT`
-
-``` purescript
-runContT :: forall r m a. ContT r m a -> (a -> m r) -> m r
-```
-
-Run a computation in the `ContT` monad, by providing a continuation.
-
-#### `mapContT`
-
-``` purescript
-mapContT :: forall r m a. (m r -> m r) -> ContT r m a -> ContT r m a
-```
-
-Modify the underlying action in a `ContT` monad action.
-
-#### `withContT`
-
-``` purescript
-withContT :: forall r m a b. ((b -> m r) -> a -> m r) -> ContT r m a -> ContT r m b
-```
-
-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))
-```
-
-
 ## Module Control.Monad.Trans
 
 This module defines the `MonadTrans` type class of _monad transformers_.

docs/Control.Monad.Writer.md

@@ -133,6 +133,7 @@ instance monadWriterT :: (Monoid w, Monad m) => Monad (WriterT w m)
 instance monadRecWriterT :: (Monoid w, MonadRec m) => MonadRec (WriterT w m)
 instance monadPlusWriterT :: (Monoid w, MonadPlus m) => MonadPlus (WriterT w m)
 instance monadTransWriterT :: (Monoid w) => MonadTrans (WriterT w)
+instance monadEffWriter :: (Monad m, Monoid w, MonadEff eff m) => MonadEff eff (WriterT w m)
 ```
 
 #### `runWriterT`

gulpfile.js

@@ -54,7 +54,7 @@ gulp.task("docs", ["clean-docs"], function () {
         "Control.Comonad.Trans": "docs/Control.Comonad.Trans.md",
 
         "Control.Monad.Cont.Class": "docs/Control.Monad.Cont.md",
-        "Control.Monad.Cont.Trans": "docs/Control.Monad.Trans.md",
+        "Control.Monad.Cont.Trans": "docs/Control.Monad.Cont.md",
 
         "Control.Monad.Error": "docs/Control.Monad.Error.md",
         "Control.Monad.Error.Class": "docs/Control.Monad.Error.md",