unliftio-core- The MonadUnliftIO typeclass for unlifting monads to IO

Safe HaskellSafe



Please see the README.md file for information on using this package at https://www.stackage.org/package/unliftio-core.



class MonadIO m => MonadUnliftIO m where Source #

Monads which allow their actions to be run in IO.

While MonadIO allows an IO action to be lifted into another monad, this class captures the opposite concept: allowing you to capture the monadic context. Note that, in order to meet the laws given below, the intuition is that a monad must have no monadic state, but may have monadic context. This essentially limits MonadUnliftIO to ReaderT and IdentityT transformers on top of IO.

Laws. For any value u returned by askUnliftIO, it must meet the monad transformer laws as reformulated for MonadUnliftIO:

  • unliftIO u . return = return
  • unliftIO u (m >>= f) = unliftIO u m >>= unliftIO u . f

The third is a currently nameless law which ensures that the current context is preserved.

  • askUnliftIO >>= (u -> liftIO (unliftIO u m)) = m

If you have a name for this, please submit it in a pull request for great glory.


Minimal complete definition

askUnliftIO | withRunInIO


askUnliftIO :: m (UnliftIO m) Source #

Capture the current monadic context, providing the ability to run monadic actions in IO.

See UnliftIO for an explanation of why we need a helper datatype here. @since

withRunInIO :: ((forall a. m a -> IO a) -> IO b) -> m b Source #

Convenience function for capturing the monadic context and running an IO action with a runner function. The runner function is used to run a monadic action m in IO.



MonadUnliftIO IO Source # 


askUnliftIO :: IO (UnliftIO IO) Source #

withRunInIO :: ((forall a. IO a -> IO a) -> IO b) -> IO b Source #

MonadUnliftIO m => MonadUnliftIO (IdentityT * m) Source # 


askUnliftIO :: IdentityT * m (UnliftIO (IdentityT * m)) Source #

withRunInIO :: ((forall a. IdentityT * m a -> IO a) -> IO b) -> IdentityT * m b Source #

MonadUnliftIO m => MonadUnliftIO (ReaderT * r m) Source # 


askUnliftIO :: ReaderT * r m (UnliftIO (ReaderT * r m)) Source #

withRunInIO :: ((forall a. ReaderT * r m a -> IO a) -> IO b) -> ReaderT * r m b Source #

newtype UnliftIO m Source #

The ability to run any monadic action m a as IO a.

This is more precisely a natural transformation. We need to new datatype (instead of simply using a forall) due to lack of support in GHC for impredicative types.





askRunInIO :: MonadUnliftIO m => m (m a -> IO a) Source #

Same ask askUnliftIO, but returns a monomorphic function instead of a polymorphic newtype wrapper. If you only need to apply the transformation on one concrete type, this function can be more convenient.


withUnliftIO :: MonadUnliftIO m => (UnliftIO m -> IO a) -> m a Source #

Convenience function for capturing the monadic context and running an IO action. The UnliftIO newtype wrapper is rarely needed, so prefer withRunInIO to this function.


toIO :: MonadUnliftIO m => m a -> m (IO a) Source #

Convert an action in m to an action in IO.


class Monad m => MonadIO (m :: * -> *) where #

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

Minimal complete definition



liftIO :: IO a -> m a #

Lift a computation from the IO monad.


MonadIO IO



liftIO :: IO a -> IO a #

MonadIO m => MonadIO (IdentityT * m) 


liftIO :: IO a -> IdentityT * m a #

MonadIO m => MonadIO (ReaderT * r m) 


liftIO :: IO a -> ReaderT * r m a #