I started playing with type families. I wanted to achieve, for the beginning, something like:
import qualified Control.Monad.IO.Class as IOC import Control.Monad.Trans.Class import Control.Monad.Trans.Cont import Data.Functor.Identity
class (Monad m, Monad (IO' m)) => MonadIO m where type IO' m :: * -> * liftIO :: IO a -> IO' m a liftM :: m a -> IO' m a
It allows to add IO to computation even if computation originally was 'pure'. First step was easy:
instance MonadIO Identity where type IO' Identity = IO liftIO = id liftM = return . runIdentity
instance MonadIO IO where type IO' IO = IO liftIO = id liftM = id
instance MonadIO (ST r) where type IO' (ST r) = IO liftIO = id liftM = unsafeSTToIO
--instance IOC.MonadIO m => MonadIO m where --type IO' m = m --liftIO = IOC.liftIO --liftM = id
However I run into problems - this code doesn't want to compile:
instance MonadIO m => MonadIO (ContT r m) where type IO' (ContT r m) = ContT r (IO' m) liftIO f = ContT $ \cont -> liftIO f >>= cont liftM f = ContT $ \cont -> liftM f >>= cont
Or this:
instance MonadIO m => MonadIO (ContT r m) where type IO' (ContT r m) = ContT r (IO' m) liftIO f = lift . liftIO liftM f = lift . liftIO
In fact there is strange interfering types of ghci: ghci> :t lift . liftIO lift . liftIO :: (m ~ IO' m1, MonadTrans t, Monad m, MonadIO m1) => IO a -> t m a ghci> :t lift . liftIO :: (m ~ IO' m1, MonadTrans t, Monad m, MonadIO m1) => IO a -> t m a <interactive>:1:7: Couldn't match expected type `IO' m' against inferred type `m1' `m1' is a rigid type variable bound by an expression type signature at <interactive>:1:18 NB: `IO'' is a type function, and may not be injective In the second argument of `(.)', namely `liftIO' In the expression: lift . liftIO :: (m ~ (IO' m1), MonadTrans t, Monad m, MonadIO m1) => IO a -> t m a What's the problem? I guess I don't understand something basic about type famillies. Regards