Control.ContStuff

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

Monad transformers

Identity transformer

newtype IdT m a

The identity monad transformer. This monad transformer represents computations themselves without further side effects. Unlike most other monad transformers in this module it is not implemented in terms of continuation passing style.

Constructors

IdT

Fields

getIdT :: m a

Instances

Transformer IdT

Runnable IdT r m r

Monad m => Monad (IdT m)

Functor m => Functor (IdT m)

MonadFix m => MonadFix (IdT m)

(Alternative m, Monad m) => MonadPlus (IdT m)

Applicative m => Applicative (IdT m)

Alternative m => Alternative (IdT m)

(LiftBase m, Monad m) => LiftBase (IdT 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

Transformer (ContT r)

Runnable (ContT r) r m a

Monad (ContT r m)

Functor (ContT r m)

Alternative m => MonadPlus (ContT r m)

Applicative (ContT r m)

Alternative m => Alternative (ContT r m)

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

(LiftBase m, Monad m) => LiftBase (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

Transformer (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)

(LiftBase m, Monad m) => LiftBase (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 () 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 () 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

Transformer (EitherT r e)

Runnable (EitherT r e) r m a

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)

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

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

HasExceptions (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.

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

Transformer (MaybeT r)

Runnable (MaybeT r) r m a

Monad (MaybeT r m)

Functor (MaybeT r m)

Alternative m => MonadPlus (MaybeT r m)

Applicative (MaybeT r m)

Alternative (MaybeT r m)

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

HasExceptions (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.

State

newtype StateT r s m a

Monad transformer for stateful computations.

Constructors

StateT

Fields

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

Instances

Transformer (StateT r s)

Runnable (StateT r s) r m a

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)

Stateful (StateT r s m)

(LiftBase m, Monad m) => LiftBase (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.

Monads

Identity monad

newtype Id a

The identity monad. This monad represents values themselves, i.e. computations without effects.

Constructors

Id

Fields

getId :: a

Instances

Monad Id

Functor Id

MonadFix Id

Applicative Id

LiftBase Id

Show a => Show (Id a)

Choice

type Choice r i a = ChoiceT r i Id a

The choice monad. Derived from ChoiceT.

listChoice :: Choice [a] [a] a -> [a]

Get list of solutions.

maybeChoice :: Choice (Maybe a) (Maybe a) a -> Maybe a

Get one solution.

Cont

type Cont r a = ContT r Id a

Pure CPS monad derived from ContT.

runCont :: (a -> r) -> Cont r a -> r

Run a pure CPS computation.

evalCont :: Cont r r -> r

Evaluate a pure CPS computation to its final result.

modifyCont :: (r -> r) -> Cont r ()

Modify the result of a CPS computation along the way.

State

type State r s a = StateT r s Id a

Pure state monad derived from StateT.

runState :: s -> (s -> a -> r) -> State r s a -> r

Run a stateful computation.

evalState :: s -> State r s r -> r

Run a stateful computation returning its result.

execState :: s -> State s s a -> s

Run a stateful computation returning its result.

Writer

type OldWriter r w a = ContT (r, w) Id a

The traditional writer monad.

runOldWriter :: Monoid w => OldWriter r w r -> (r, w)

Run a traditional writer computation.

evalOldWriter :: Monoid w => OldWriter r w r -> r

Run a traditional writer computation and return its result.

execOldWriter :: Monoid w => OldWriter r w r -> w

Run a traditional writer computation and return its log.

Effect classes

Abortion

class Abortable m where

Monads supporting abortion.

Associated Types

type Result m

End result of the computation.

Methods

abort :: Result m -> m a

Ignore current continuation and abort.

Instances

Applicative m => Abortable (MaybeT r m)

Applicative m => Abortable (ContT r m)

Applicative m => Abortable (StateT r s m)

Applicative m => Abortable (EitherT r e m)

Applicative m => Abortable (ChoiceT r i m)

Call with current continuation

class CallCC m where

Monads supporting *call-with-current-continuation* (aka callCC).

Methods

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

Call with current continuation.

Instances

CallCC (MaybeT r m)

CallCC (ContT r m)

CallCC (StateT r s m)

CallCC (EitherT r e m)

data Label m a

labelCC :: (Applicative m, CallCC m) => a -> m (a, Label m a)

Capture the current continuation for later use.

goto :: Label m a -> a -> m ()

Jump to a label.

Exceptions

class HasExceptions m where

Monads with exception support.

Associated Types

type Exception m

The exception type.

Methods

raise :: Exception m -> m a

Raise an exception.

try :: m a -> m (Either (Exception m) a)

Run computation catching exceptions.

Instances

HasExceptions IO

HasExceptions Maybe

HasExceptions (Either e)

HasExceptions (MaybeT r m)

HasExceptions (EitherT r e m)

bracket :: (HasExceptions m, Monad m) => m res -> (res -> m b) -> (res -> m a) -> m a

Get a resource, run a computation, then release the resource, even if an exception is raised:

 bracket acquire release use

Please note that this function behaves slightly different from the usual bracket. If both the user and the releaser throw an exception, the user exception is significant.

bracket_ :: (HasExceptions m, Monad m) => m a -> m b -> m c -> m c

Initialize, then run, then clean up safely, even if an exception is raised:

 bracket_ init cleanup run

Please note that this function behaves slightly different from the usual bracket_. If both the user and the releaser throw an exception, the user exception is significant.

catch :: (HasExceptions m, Monad m) => m a -> (Exception m -> m a) -> m a

Catch exceptions using an exception handler.

finally :: (HasExceptions m, Monad m) => m a -> m b -> m a

Run a final computation regardless of whether an exception was raised.

forbid :: (Exception (t m) ~ (), HasExceptions (t m), Monad m, Monad (t m), Transformer t) => m Bool -> t m ()

Fail (in the sense of the given transformer), if the given underlying computation returns True.

handle :: (HasExceptions m, Monad m) => (Exception m -> m a) -> m a -> m a

Catch exceptions using an exception handler (flip catch).

raiseUnless :: (HasExceptions m, Monad m) => Exception m -> m Bool -> m ()

Throw given exception, if the given computation returns False.

raiseWhen :: (HasExceptions m, Monad m) => Exception m -> m Bool -> m ()

Throw given exception, if the given computation returns True.

require :: (Exception (t m) ~ (), HasExceptions (t m), Monad m, Monad (t m), Transformer t) => m Bool -> t m ()

Fail (in the sense of the given transformer), if the given underlying computation returns False.

Lifting

class Transformer t where

The monad transformer class. Lifting computations one level down the monad stack, or stated differently promoting a computation of the underlying monad to the transformer.

Methods

lift :: Monad m => m a -> t m a

Promote a monadic computation to the transformer.

Instances

Transformer IdT

Transformer (MaybeT r)

Transformer (ContT r)

Transformer (StateT r s)

Transformer (EitherT r e)

Transformer (ChoiceT r i)

class LiftBase m where

Monads, which support lifting base monad computations.

Associated Types

type Base m :: * -> *

Base monad of m.

Methods

base :: Base m a -> m a

Promote a base monad computation.

Instances

LiftBase []

LiftBase IO

LiftBase Maybe

LiftBase Id

LiftBase ((->) r)

LiftBase (ST s)

(LiftBase m, Monad m) => LiftBase (IdT m)

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

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

(LiftBase m, Monad m) => LiftBase (StateT r s m)

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

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

io :: (LiftBase m, Base m ~ IO) => Base m a -> m a

Handy alias for lifting IO computations.

Running

class Runnable t r m a where

Every monad transformer t that supports transforming t m a to m a can be an instance of this class.

Associated Types

type Argument t r m a

Arguments needed to run.

Methods

runT :: Argument t r m a -> t m a -> m r

Run the transformer.

Instances

Runnable IdT r m r

Runnable (MaybeT r) r m a

Runnable (ContT r) r m a

Runnable (StateT r s) r m a

Runnable (EitherT r e) r m a

State

class Stateful m where

Stateful monads.

Minimal complete definition: StateOf, get and putLazy.

Associated Types

type StateOf m

State type of m.

Methods

get :: m (StateOf m)

Get the current state.

put :: StateOf m -> m ()

Set the current state and force it.

putLazy :: StateOf m -> m ()

Set the current state, but don't force it.

Instances

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

Stateful (StateT r s m)

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

getField :: (Functor m, Stateful m) => (StateOf m -> a) -> m a

Get a certain field.

modify :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()

Apply a function to the current state.

modifyField :: (Monad m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()

Get a field and modify the state.

modifyFieldLazy :: (Monad m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()

Get a field and modify the state. Lazy version.

modifyLazy :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()

Apply a function to the current state. Lazy version.

Logging support (writers)

class Writable m w where

Monads with support for logging. Traditionally these are called *writer monads*.

Methods

tell :: w -> m ()

Log a value.

Instances

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

Alternative m => Writable (MaybeT r m) r

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

Alternative m => Writable (ContT r m) r

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

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

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

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

Module reexports

module Control.Applicative

module Control.Monad