Add Affable class

Author: garyb

bower.json

@@ -22,9 +22,10 @@
     "package.json"
   ],
   "dependencies": {
-    "purescript-console":      "^0.1.0",
-    "purescript-exceptions":   "^0.3.0",
-    "purescript-functions":    "^0.1.0",
+    "purescript-console": "^0.1.0",
+    "purescript-exceptions": "^0.3.0",
+    "purescript-free": "^0.9.1",
+    "purescript-functions": "^0.1.0",
     "purescript-transformers": "^0.8.1"
   }
 }

src/Control/Monad/Aff/Class.purs

@@ -5,6 +5,7 @@ import Prelude
 import Control.Monad.Aff (Aff())
 import Control.Monad.Cont.Trans (ContT())
 import Control.Monad.Except.Trans (ExceptT())
+import Control.Monad.Free (Free(), liftF)
 import Control.Monad.List.Trans (ListT())
 import Control.Monad.Maybe.Trans (MaybeT())
 import Control.Monad.Reader.Trans (ReaderT())
@@ -15,32 +16,50 @@ import Control.Monad.Writer.Trans (WriterT())
 
 import Data.Monoid (Monoid)
 
-class MonadAff e m where
+-- | A class for types that can carry an `Aff` value by some means.
+class Affable e m where
   liftAff :: forall a. Aff e a -> m a
 
-instance monadAffAff :: MonadAff e (Aff e) where
+instance affableAff :: Affable e (Aff e) where
   liftAff = id
 
-instance monadAffContT :: (Monad m, MonadAff eff m) => MonadAff eff (ContT r m) where
+instance affableFree :: (Affable eff f) => Affable eff (Free f) where
+  liftAff = liftF <<< liftAff
+
+instance affableContT :: (Monad m, Affable eff m) => Affable eff (ContT r m) where
   liftAff = lift <<< liftAff
 
-instance monadAffExceptT :: (Monad m, MonadAff eff m) => MonadAff eff (ExceptT e m) where
+instance affableExceptT :: (Monad m, Affable eff m) => Affable eff (ExceptT e m) where
   liftAff = lift <<< liftAff
 
-instance monadAffListT :: (Monad m, MonadAff eff m) => MonadAff eff (ListT m) where
+instance affableListT :: (Monad m, Affable eff m) => Affable eff (ListT m) where
   liftAff = lift <<< liftAff
 
-instance monadAffMaybe :: (Monad m, MonadAff eff m) => MonadAff eff (MaybeT m) where
+instance affableMaybe :: (Monad m, Affable eff m) => Affable eff (MaybeT m) where
   liftAff = lift <<< liftAff
 
-instance monadAffReader :: (Monad m, MonadAff eff m) => MonadAff eff (ReaderT r m) where
+instance affableReader :: (Monad m, Affable eff m) => Affable eff (ReaderT r m) where
   liftAff = lift <<< liftAff
 
-instance monadAffRWS :: (Monad m, Monoid w, MonadAff eff m) => MonadAff eff (RWST r w s m) where
+instance affableRWS :: (Monad m, Monoid w, Affable eff m) => Affable eff (RWST r w s m) where
   liftAff = lift <<< liftAff
 
-instance monadAffState :: (Monad m, MonadAff eff m) => MonadAff eff (StateT s m) where
+instance affableState :: (Monad m, Affable eff m) => Affable eff (StateT s m) where
   liftAff = lift <<< liftAff
 
-instance monadAffWriter :: (Monad m, Monoid w, MonadAff eff m) => MonadAff eff (WriterT w m) where
+instance affableWriter :: (Monad m, Monoid w, Affable eff m) => Affable eff (WriterT w m) where
   liftAff = lift <<< liftAff
+
+--| A class for types where the `Affable` instance for a `Monad` is also a monad
+--| morphism.
+class (Monad m, Affable e m) <= MonadAff e m
+
+instance monadAffAff :: MonadAff e (Aff e)
+instance monadAffContT :: (Monad m, Affable eff m) => MonadAff eff (ContT r m)
+instance monadAffExceptT :: (Monad m, Affable eff m) => MonadAff eff (ExceptT e m)
+instance monadAffListT :: (Monad m, Affable eff m) => MonadAff eff (ListT m)
+instance monadAffMaybe :: (Monad m, Affable eff m) => MonadAff eff (MaybeT m)
+instance monadAffReader :: (Monad m, Affable eff m) => MonadAff eff (ReaderT r m)
+instance monadAffRWS :: (Monad m, Monoid w, Affable eff m) => MonadAff eff (RWST r w s m)
+instance monadAffState :: (Monad m, Affable eff m) => MonadAff eff (StateT s m)
+instance monadAffWriter :: (Monad m, Monoid w, Affable eff m) => MonadAff eff (WriterT w m)