Merge pull request #46 from purescript/eff

Add MonadEff instances

Author: paf31

src/Control/Monad/Cont/Trans.purs

@@ -5,6 +5,7 @@ module Control.Monad.Cont.Trans where
 import Prelude
 
 import Control.Monad.Trans
+import Control.Monad.Eff.Class
 
 -- | The CPS monad transformer.
 -- |
@@ -53,3 +54,6 @@ instance monadContT :: (Monad m) => Monad (ContT r m)
 
 instance monadTransContT :: MonadTrans (ContT r) where
   lift m = ContT (\k -> m >>= k)
+
+instance monadEffContT :: (Monad m, MonadEff eff m) => MonadEff eff (ContT r m) where
+  liftEff = lift <<< liftEff

src/Control/Monad/Error/Trans.purs

@@ -10,6 +10,7 @@ import Control.Apply
 import Control.Monad.Error
 import Control.Monad.Rec.Class
 import Control.Monad.Trans
+import Control.Monad.Eff.Class
 import Control.MonadPlus
 import Control.Plus
 import Data.Either
@@ -75,6 +76,9 @@ instance monadTransErrorT :: MonadTrans (ErrorT e) where
     a <- m
     return $ Right a
 
+instance monadEffError :: (Monad m, MonadEff eff m) => MonadEff eff (ErrorT e m) where
+  liftEff = lift <<< liftEff
+
 liftListenError :: forall e m a w. (Monad m) => (m (Either e a) -> m (Tuple (Either e a) w)) -> ErrorT e m a -> ErrorT e m (Tuple a w)
 liftListenError listen = mapErrorT $ \m -> do
   Tuple a w <- listen m

src/Control/Monad/Except/Trans.purs

@@ -6,6 +6,8 @@ import Prelude
 import Control.Alt (Alt)
 import Control.Alternative (Alternative)
 import Control.Monad.Rec.Class (MonadRec, tailRecM)
+import Control.Monad.Eff.Class (MonadEff, liftEff)
+import Control.Monad.Trans
 import Control.MonadPlus (MonadPlus)
 import Control.Plus (Plus)
 import Data.Either (Either(..), either)
@@ -76,6 +78,14 @@ 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) where
+  lift m = ExceptT $ do
+    a <- m
+    return $ Right a
+
+instance monadEffExceptT :: (Monad m, MonadEff eff m) => MonadEff eff (ExceptT e m) where
+  liftEff = lift <<< liftEff
+
 -- | Throw an exception in an `ExceptT` computation.
 throwE :: forall e m a. (Applicative m) => e -> ExceptT e m a
 throwE = ExceptT <<< pure <<< Left

src/Control/Monad/List/Trans.purs

@@ -33,8 +33,9 @@ module Control.Monad.List.Trans
 import Prelude
 import Control.Alt (Alt)
 import Control.Alternative (Alternative)
-import Control.Monad.Trans (MonadTrans)
+import Control.Monad.Trans (MonadTrans, lift)
 import Control.MonadPlus (MonadPlus)
+import Control.Monad.Eff.Class
 import Control.Plus (Plus)
 import Data.Lazy (Lazy(), defer, force)
 import Data.Maybe (Maybe(..), fromMaybe)
@@ -278,3 +279,6 @@ instance plusListT :: (Monad f) => Plus (ListT f) where
 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) where
+  liftEff = lift <<< liftEff

src/Control/Monad/Maybe/Trans.purs

@@ -9,6 +9,7 @@ import Control.Alternative
 import Control.Monad
 import Control.Monad.Rec.Class
 import Control.Monad.Trans
+import Control.Monad.Eff.Class
 import Control.MonadPlus
 import Control.Plus
 import Data.Either
@@ -72,6 +73,9 @@ instance monadRecMaybeT :: (MonadRec m) => MonadRec (MaybeT m) where
       Just (Left a1) -> Left a1
       Just (Right b) -> Right (Just b)
 
+instance monadEffMaybe :: (Monad m, MonadEff eff m) => MonadEff eff (MaybeT m) where
+  liftEff = lift <<< liftEff
+
 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
 liftCatchMaybe catch m h = MaybeT $ catch (runMaybeT m) (runMaybeT <<< h)
 

src/Control/Monad/RWS/Trans.purs

@@ -5,6 +5,7 @@ module Control.Monad.RWS.Trans where
 import Prelude
 
 import Control.Monad.Trans
+import Control.Monad.Eff.Class
 import Data.Monoid
 import Data.Tuple
 
@@ -63,3 +64,6 @@ instance monadRWST :: (Monad m, Monoid w) => Monad (RWST r w s m)
 
 instance monadTransRWST :: (Monoid w) => MonadTrans (RWST r w s) where
   lift m = RWST \_ s -> m >>= \a -> return $ mkSee s a mempty
+
+instance monadEffRWS :: (Monad m, Monoid w, MonadEff eff m) => MonadEff eff (RWST r w s m) where
+  liftEff = lift <<< liftEff

src/Control/Monad/Reader/Trans.purs

@@ -9,6 +9,7 @@ import Control.Alternative
 import Control.Plus
 import Control.Monad.Trans
 import Control.MonadPlus
+import Control.Monad.Eff.Class
 
 -- | The reader monad transformer.
 -- |
@@ -59,6 +60,9 @@ instance monadPlusReaderT :: (MonadPlus m) => MonadPlus (ReaderT r m)
 instance monadTransReaderT :: MonadTrans (ReaderT r) where
   lift = liftReaderT
 
+instance monadEffReader :: (Monad m, MonadEff eff m) => MonadEff eff (ReaderT r m) where
+  liftEff = lift <<< liftEff
+
 liftReaderT :: forall r m a. m a -> ReaderT r m a
 liftReaderT m = ReaderT (const m)
 

src/Control/Monad/State/Trans.purs

@@ -8,6 +8,7 @@ import Control.Alt
 import Control.Alternative
 import Control.Lazy
 import Control.Monad.Rec.Class
+import Control.Monad.Eff.Class
 import Control.Monad.Trans
 import Control.MonadPlus
 import Control.Plus
@@ -85,6 +86,9 @@ instance monadTransStateT :: MonadTrans (StateT s) where
 instance lazyStateT :: Lazy (StateT s m a) where
   defer f = StateT $ \s -> runStateT (f unit) s
 
+instance monadEffState :: (Monad m, MonadEff eff m) => MonadEff eff (StateT s m) where
+  liftEff = lift <<< liftEff
+
 liftCatchState :: forall s m e a. (m (Tuple a s) -> (e -> m (Tuple a s)) -> m (Tuple a s)) -> StateT s m a -> (e -> StateT s m a) -> StateT s m a
 liftCatchState catch m h = StateT $ \s -> catch (runStateT m s) (\e -> runStateT (h e) s)
 

src/Control/Monad/Writer/Trans.purs

@@ -7,6 +7,7 @@ import Prelude
 import Control.Alt
 import Control.Alternative
 import Control.Monad.Rec.Class
+import Control.Monad.Eff.Class
 import Control.Monad.Trans
 import Control.MonadPlus
 import Control.Plus
@@ -77,6 +78,9 @@ instance monadTransWriterT :: (Monoid w) => MonadTrans (WriterT w) where
     a <- m
     return $ Tuple a mempty
 
+instance monadEffWriter :: (Monad m, Monoid w, MonadEff eff m) => MonadEff eff (WriterT w m) where
+  liftEff = lift <<< liftEff
+
 liftCatchWriter :: forall w m e a. (m (Tuple a w) -> (e -> m (Tuple a w)) -> m (Tuple a w)) -> WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a
 liftCatchWriter catch m h = WriterT $ catch (runWriterT m) (\e -> runWriterT (h e))