Control.Effect.Cont

The continuation effect, similar to the MonadCont type class from the mtl library.

Tagged Continuation Effect

class Monad m => Cont' tag m where

An effect that adds an abortive continuation to a computation.

Methods

callCC' :: ((a -> m b) -> m a) -> m a

Adapted from the mtl library documentation:

callCC' (call-with-current-continuation) calls a function with the current continuation as its argument. Provides an escape continuation mechanism for use with continuation monads. Escape continuations allow to abort the current computation and return a value immediately. They achieve a similar result to throwError' and catchError' of the Error' effect. Advantage of this function over calling return is that it makes the continuation explicit, allowing more flexibility and better control.

The standard idiom used with callCC' is to provide a lambda-expression to name the continuation. Then calling the named continuation anywhere within its scope will escape from the computation, even if it is many layers deep within nested computations.

Instances

Handle (Cont' tag) t m => Cont' (tag :: k) (EachVia (Cont' tag ': effs) t m)

Defined in Control.Effect.Cont

Methods

callCC' :: ((a -> EachVia (Cont' tag ': effs) t m b) -> EachVia (Cont' tag ': effs) t m a) -> EachVia (Cont' tag ': effs) t m a

Find (Cont' tag) effs t m => Cont' (tag :: k) (EachVia (other ': effs) t m)

Defined in Control.Effect.Cont

Methods

callCC' :: ((a -> EachVia (other ': effs) t m b) -> EachVia (other ': effs) t m a) -> EachVia (other ': effs) t m a

Cont' (tag :: k1) (ContT r m)

Defined in Control.Effect.Cont

Methods

callCC' :: ((a -> ContT r m b) -> ContT r m a) -> ContT r m a

Control (Cont' tag) t m => Cont' (tag :: k) (EachVia ('[] :: [Effect]) t m)

Defined in Control.Effect.Cont

Methods

callCC' :: ((a -> EachVia '[] t m b) -> EachVia '[] t m a) -> EachVia '[] t m a

Cont' new m => Cont' (tag :: k2) (Tagger tag new m)

Defined in Control.Effect.Cont

Methods

callCC' :: ((a -> Tagger tag new m b) -> Tagger tag new m a) -> Tagger tag new m a

Untagged Continuation Effect

If you don't require disambiguation of multiple continuation effects (i.e., you only have one continuation effect in your monadic context), it is recommended to always use the untagged continuation effect.

type Cont = Cont' G

callCC :: Cont m => ((a -> m b) -> m a) -> m a

Interpretations

runCont' :: forall tag r m a. (a -> m r) -> (Cont' tag `Via` ContT r) m a -> m r

Runs the continuation effect with a given final continuation.

runCont :: (a -> m r) -> (Cont `Via` ContT r) m a -> m r

The untagged version of runCont'.

evalCont' :: forall tag r m. Applicative m => (Cont' tag `Via` ContT r) m r -> m r

Runs the continuation effect with pure as final continuation.

evalCont :: Applicative m => (Cont `Via` ContT r) m r -> m r

The untagged version of evalCont'.

Tagging and Untagging

Conversion functions between the tagged and untagged continuation effect, usually used in combination with type applications, like:

    tagCont' @"newTag" program
    retagCont' @"oldTag" @"newTag" program
    untagCont' @"erasedTag" program

tagCont' :: forall new m a. Via (Cont' G) (Tagger G new) m a -> m a

retagCont' :: forall tag new m a. Via (Cont' tag) (Tagger tag new) m a -> m a

untagCont' :: forall tag m a. Via (Cont' tag) (Tagger tag G) m a -> m a