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)

Applicative m => Applicative (IdT m)

Alternative m => Alternative (IdT m)

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

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)

Applicative (ContT r m)

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

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

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

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)

Applicative (ChoiceT r i m)

Alternative (ChoiceT r i m)

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

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

Run a choice computation.

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

Find the first solution.

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

Find all solutions.

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

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

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

Turn a list into a computation with alternatives.

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)

Applicative (EitherT r e m)

Alternative m => Alternative (EitherT r e m)

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

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

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.

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)

Applicative (StateT r s m)

Alternative m => Alternative (StateT r s m)

Stateful (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

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

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 a

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

Methods

abort :: Result m -> m a

Instances

Applicative m => Abortable (ContT r m)

Applicative m => Abortable (StateT r s m)

Applicative m => Abortable (EitherT r e 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 (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 (EitherT r e m)

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

Catch exceptions using an exception handler.

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

Catch exceptions using an exception handler (flip catch).

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

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

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.

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 (ContT r)

Transformer (StateT r s)

Transformer (EitherT r e)

Transformer (ChoiceT r i)

class LiftBase m a where

Monads, which support lifting base monad computations.

Associated Types

type Base m a

Methods

base :: Base m a -> m a

Instances

LiftBase [] a

LiftBase IO a

LiftBase Maybe a

LiftBase Id a

LiftBase ((->) r) a

LiftBase (ST s) a

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

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

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

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

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

io :: (LiftBase m a, Base m a ~ IO a) => 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

Methods

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

Instances

Runnable IdT r m r

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.

Associated Types

type StateOf 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 ()

Instances

(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