Control.Monad.Cont.Trans

newtype ContT r m a

The CPS monad transformer.

This monad transformer extends the base monad with the operation callCC.

Constructors

• ContT ((a -> m r) -> m r)

Instances

• Newtype (ContT r m a) _
• (Monad m) => MonadCont (ContT r m)
• (Functor m) => Functor (ContT r m)
• (Apply m) => Apply (ContT r m)
• (Applicative m) => Applicative (ContT r m)
• (Bind m) => Bind (ContT r m)
• (Monad m) => Monad (ContT r m)
• MonadTrans (ContT r)
• (MonadEff eff m) => MonadEff eff (ContT r m)
• (MonadAsk r1 m) => MonadAsk r1 (ContT r m)
• (MonadReader r1 m) => MonadReader r1 (ContT r m)
• (MonadState s m) => MonadState s (ContT r m)

runContT :: forall a m r. ContT r m a -> (a -> m r) -> m r

Run a computation in the ContT monad, by providing a continuation.

mapContT :: forall a m r. (m r -> m r) -> ContT r m a -> ContT r m a

Modify the underlying action in a ContT monad action.

withContT :: forall b a m r. ((b -> m r) -> (a -> m r)) -> ContT r m a -> ContT r m b

Modify the continuation in a ContT monad action

class (Monad m) <= MonadCont m  where

The MonadCont type class represents those monads which support the callCC, or call-with-current-continuation operation.

This action makes the current continuation available to the caller.

For example:

delay :: forall eff. Number -> ContT Unit (Eff (timeout :: Timeout | eff)) Unit
delay n = callCC \cont ->
  lift $ setTimeout n (runContT (cont unit) (\_ -> return unit))

An implementation is provided for ContT, and for other monad transformers defined in this library.

Members

• callCC :: forall a. ((forall b. a -> m b) -> m a) -> m a

class MonadTrans t  where

The MonadTrans type class represents monad transformers.

A monad transformer is a type constructor of kind (* -> *) -> * -> *, which takes a Monad as its first argument, and returns another Monad.

This allows us to add additional effects to an existing monad. By iterating this process, we create monad transformer stacks, which contain all of the effects required for a particular computation.

The laws state that lift is a Monad morphism.

Laws:

• lift (pure a) = pure a
• lift (do { x <- m ; y }) = do { x <- lift m ; lift y }

Members

• lift :: forall a m. Monad m => m a -> t m a