ContT -package:monadology

newtype ContT (r :: k) (m :: k -> Type) a

mtl Control.Monad.Cont, monads-tf Control.Monad.Cont, mtl-prelude MTLPrelude

The continuation monad transformer. Can be used to add continuation handling to any type constructor: the Monad instance and most of the operations do not require m to be a monad. ContT is not a functor on the category of monads, and many operations cannot be lifted through it.

ContT :: ((a -> m r) -> m r) -> ContT (r :: k) (m :: k -> Type) a

mtl Control.Monad.Cont, monads-tf Control.Monad.Cont, rebase Rebase.Prelude, mtl-prelude MTLPrelude

newtype ContT r m a

transformers Control.Monad.Trans.Cont

The continuation monad transformer. Can be used to add continuation handling to any type constructor: the Monad instance and most of the operations do not require m to be a monad. ContT is not a functor on the category of monads, and many operations cannot be lifted through it. ContT r m is strict if and only if m is.

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

transformers Control.Monad.Trans.Cont

newtype () => ContT (r :: k) (m :: k -> Type) a

rebase Rebase.Prelude

The continuation monad transformer. Can be used to add continuation handling to any type constructor: the Monad instance and most of the operations do not require m to be a monad. ContT is not a functor on the category of monads, and many operations cannot be lifted through it.

type family ContTuple (xs :: [Type]) r

variant Data.Variant.ContFlow

Convert a list of types into the actual data type representing the continuations.

conTToName :: Type -> Name

deriving-compat Data.Deriving.Internal

Extract the Name from a type constructor. If the argument Type is not a type variable, throw an error.

contToState :: BirthPos -> Results s t a -> Cont s r e t a c -> State s r e t c

Earley Text.Earley.Generator.Internal

contToState :: BirthPos -> Results s a -> Cont s r e t a c -> State s r e t c

Earley Text.Earley.Parser.Internal

contToVariant :: ContVariant xs => ContFlow xs (V xs) -> V xs

variant Data.Variant

Convert a multi-continuation into a Variant

contToVariantM :: (ContVariant xs, Monad m) => ContFlow xs (m (V xs)) -> m (V xs)

variant Data.Variant

Convert a multi-continuation into a Variant

contToEADT :: ContVariant (ApplyAll (EADT xs) xs) => ContFlow (ApplyAll (EADT xs) xs) (V (ApplyAll (EADT xs) xs)) -> EADT xs

variant Data.Variant.EADT

Convert a multi-continuation into an EADT

contToEADTM :: (ContVariant (ApplyAll (EADT xs) xs), Monad f) => ContFlow (ApplyAll (EADT xs) xs) (f (V (ApplyAll (EADT xs) xs))) -> f (EADT xs)

variant Data.Variant.EADT

Convert a multi-continuation into an EADT

contToVariantF :: forall xs e . ContVariant (ApplyAll e xs) => ContFlow (ApplyAll e xs) (V (ApplyAll e xs)) -> VariantF xs e

variant Data.Variant.VariantF

Convert a multi-continuation into a VariantF

contToVariantFM :: forall xs e m . (ContVariant (ApplyAll e xs), Monad m) => ContFlow (ApplyAll e xs) (m (V (ApplyAll e xs))) -> m (VariantF xs e)

variant Data.Variant.VariantF

Convert a multi-continuation into a VariantF

evalContT :: Monad m => ContT r m r -> m r

mtl Control.Monad.Cont, transformers Control.Monad.Trans.Cont, rebase Rebase.Prelude, mtl-prelude MTLPrelude

The result of running a CPS computation with return as the final continuation.

```
evalContT (lift m) = m
```

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

mtl Control.Monad.Cont, transformers Control.Monad.Trans.Cont

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

transformers Control.Monad.Trans.Cont

Apply a function to transform the result of a continuation-passing computation. This has a more restricted type than the map operations for other monad transformers, because ContT does not define a functor in the category of monads.

runContT (mapContT f m) = f . runContT
m

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

transformers Control.Monad.Trans.Cont

Apply a function to transform the continuation passed to a CPS computation.

runContT (withContT f m) = runContT m .
f

selectToContT :: Monad m => SelectT r m a -> ContT r m a

transformers Control.Monad.Trans.Select

Convert a selection computation to a continuation-passing computation.

scContToXml :: Schema -> (Attributes, XmlTrees)

hxt Text.XML.HXT.Arrow.Pickle.DTD

runContT :: ContT (r :: k) (m :: k -> Type) a -> (a -> m r) -> m r

monads-tf Control.Monad.Cont, rebase Rebase.Prelude, mtl-prelude MTLPrelude

liftContT :: (forall a . ContT a IO ptr) -> Creator () ptr

comfort-array Data.Array.Comfort.Storable.Unchecked.Creator

mrgEvalContT :: (TryMerge m, Mergeable r, Monad m) => ContT r m r -> m r

grisette Grisette.Lib.Control.Monad.Trans.Cont

evalContT with MergingStrategy knowledge propagation.

mrgRunContT :: (TryMerge m, Mergeable r) => ContT r m a -> (a -> m r) -> m r

grisette Grisette.Lib.Control.Monad.Trans.Cont

runContT with MergingStrategy knowledge propagation.