Control.ContStuff.Trans

This module implements a number of monad transformers using a CPS approach internally.

Monad transformers

Identity transformer

newtype IdentityT m a

The trivial monad transformer, which maps a monad to an equivalent monad.

Constructors

IdentityT

Fields

runIdentityT :: m a

Instances

MonadTrans IdentityT

Monad m => Monad (IdentityT m)

Functor m => Functor (IdentityT m)

MonadPlus m => MonadPlus (IdentityT m)

Applicative m => Applicative (IdentityT m)

Alternative m => Alternative (IdentityT m)

MonadIO m => MonadIO (IdentityT m)

(Monad m, Stateful m) => Stateful (IdentityT m)

ContT

newtype ContT r m a

The continuation passing style monad transformer. This monad transformer models the most basic form of CPS.

Constructors

ContT

Fields

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

Instances

MonadTrans (ContT r)

Monad (ContT r m)

Functor (ContT r m)

Alternative m => MonadPlus (ContT r m)

Applicative (ContT r m)

Alternative m => Alternative (ContT r m)

MonadIO m => MonadIO (ContT r m)

(Monad m, Stateful m) => Stateful (ContT r m)

Forkable m => Forkable (ContT r m)

CallCC (ContT r m)

Applicative m => Abortable (ContT r m)

(Functor m, Monoid w) => Writable (ContT (r, w) m) w

Alternative m => Writable (ContT r m) r

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

Run a CPS-style computation given the supplied final continuation.

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

Evaluate a CPS-style computation to its final result.

modifyContT :: Functor m => (r -> r) -> ContT r m ()

Transform the final result along the way.

Choice/nondeterminism

newtype ChoiceT r i m a

The choice monad transformer, which models, as the most common interpretation, nondeterminism. Internally a list of choices is represented as a CPS-based left-fold function.

Constructors

ChoiceT

Fields

getChoiceT :: (i -> a -> (i -> m r) -> m r) -> i -> (i -> m r) -> m r

Instances

MonadTrans (ChoiceT r i)

Monad (ChoiceT r i m)

Functor (ChoiceT r i m)

MonadPlus (ChoiceT r i m)

Applicative (ChoiceT r i m)

Alternative (ChoiceT r i m)

MonadIO m => MonadIO (ChoiceT r i m)

(Monad m, Stateful m) => Stateful (ChoiceT r i m)

Forkable m => Forkable (ChoiceT r i m)

Applicative m => Abortable (ChoiceT r i m)

runChoiceT :: (i -> a -> (i -> m r) -> m r) -> i -> (i -> m r) -> ChoiceT r i m a -> m r

Run a choice computation.

choice :: [a] -> ChoiceT r i m a

Turn a list into a ChoiceT computation efficiently.

findAll :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)

Find all solutions.

findAll_ :: Applicative m => ChoiceT r i m a -> m ()

Find all solutions and ignore them.

findFirst :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)

Find the first solution.

findFirst_ :: Applicative m => ChoiceT r i m a -> m ()

Find the first solution and ignore it.

listA :: Alternative f => [a] -> f a

Turn a list into a computation with alternatives.

listChoiceT :: Applicative m => ChoiceT [a] [a] m a -> m [a]

Get list of solutions (faster than findAll, but returns solutions in reversed order).

maybeChoiceT :: Applicative m => ChoiceT (Maybe a) (Maybe a) m a -> m (Maybe a)

Get one solution (faster than findFirst).

Exceptions

newtype EitherT r e m a

Monad transformer for CPS computations with an additional exception continuation.

Constructors

EitherT

Fields

getEitherT :: (a -> m r) -> (e -> m r) -> m r

Instances

MonadTrans (EitherT r e)

Monad (EitherT r e m)

Functor (EitherT r e m)

Alternative m => MonadPlus (EitherT r e m)

Applicative (EitherT r e m)

Alternative m => Alternative (EitherT r e m)

MonadIO m => MonadIO (EitherT r e m)

(Monad m, Stateful m) => Stateful (EitherT r e m)

HasExceptions (EitherT r e m)

Forkable m => Forkable (EitherT r e m)

CallCC (EitherT r e m)

Applicative m => Abortable (EitherT r e m)

(Functor m, Monoid w) => Writable (EitherT (r, w) e m) w

Alternative m => Writable (EitherT r e m) r

runEitherT :: (a -> m r) -> (e -> m r) -> EitherT r e m a -> m r

Run an EitherT transformer.

evalEitherT :: Applicative m => EitherT (Either e a) e m a -> m (Either e a)

Run an EitherT transformer returning an Either result.

modifyEitherT :: Functor m => (r -> r) -> EitherT r e m ()

Modify the result of an EitherT computation along the way.

testEitherT :: Applicative m => EitherT Bool e m a -> m Bool

Run the EitherT computation and return True, if it results in a right value, False otherwise.

newtype MaybeT r m a

Monad transformer for CPS computations with an additional exception continuation with no argument.

Constructors

MaybeT

Fields

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

Instances

MonadTrans (MaybeT r)

Monad (MaybeT r m)

Functor (MaybeT r m)

Alternative m => MonadPlus (MaybeT r m)

Applicative (MaybeT r m)

Alternative (MaybeT r m)

MonadIO m => MonadIO (MaybeT r m)

(Monad m, Stateful m) => Stateful (MaybeT r m)

HasExceptions (MaybeT r m)

Forkable m => Forkable (MaybeT r m)

CallCC (MaybeT r m)

Applicative m => Abortable (MaybeT r m)

(Functor m, Monoid w) => Writable (MaybeT (r, w) m) w

Alternative m => Writable (MaybeT r m) r

runMaybeT :: (a -> m r) -> m r -> MaybeT r m a -> m r

Run a MaybeT transformer.

evalMaybeT :: Applicative m => MaybeT (Maybe a) m a -> m (Maybe a)

Run a MaybeT transformer returning a Maybe result.

modifyMaybeT :: Functor m => (r -> r) -> MaybeT r m ()

Modify the result of a MaybeT computation along the way.

testMaybeT :: Applicative m => MaybeT Bool m a -> m Bool

Run the MaybeT computation and return True, if it results in a Just value, False otherwise.

State

newtype StateT r s m a

Monad transformer for stateful computations.

Constructors

StateT

Fields

getStateT :: s -> (s -> a -> m r) -> m r

Instances

MonadTrans (StateT r s)

Monad (StateT r s m)

Functor (StateT r s m)

Alternative m => MonadPlus (StateT r s m)

Applicative (StateT r s m)

Alternative m => Alternative (StateT r s m)

MonadIO m => MonadIO (StateT r s m)

Stateful (StateT r s m)

Forkable m => Forkable (StateT r s m)

CallCC (StateT r s m)

Applicative m => Abortable (StateT r s m)

(Functor m, Monoid w) => Writable (StateT (r, w) s m) w

Alternative m => Writable (StateT r s m) r

runStateT :: s -> (s -> a -> m r) -> StateT r s m a -> m r

Run a state transformer.

evalStateT :: Applicative m => s -> StateT r s m r -> m r

Run a state transformer returning its result.

execStateT :: Applicative m => s -> StateT s s m a -> m s

Run a state transformer returning its final state.

Writer monads

type WriterT = ContT

The writer monad transformer. Supports logging effects.

runWriterT :: Alternative m => WriterT r m a -> m r

Run a writer transformer.

type OldWriterT r w m a = ContT (r, w) m a

The traditional writer monad transformer.

runOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m (r, w)

Run a traditional writer transformer.

evalOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m r

Run a traditional writer transformer and return its result.

execOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m w

Run a traditional writer transformer and return its log.