Stability | experimental |
---|---|
Maintainer | Ertugrul Soeylemez <es@ertes.de> |
This module implements a number of monad transformers using a CPS approach internally.
- newtype IdT m a = IdT {
- getIdT :: m a
- newtype ContT r m a = ContT {
- getContT :: (a -> m r) -> m r
- runContT :: (a -> m r) -> ContT r m a -> m r
- evalContT :: Applicative m => ContT r m r -> m r
- modifyContT :: Functor m => (r -> r) -> ContT r m ()
- newtype ChoiceT r i m a = ChoiceT {
- getChoiceT :: (i -> a -> (i -> m r) -> m r) -> i -> (i -> m r) -> m r
- runChoiceT :: (i -> a -> (i -> m r) -> m r) -> i -> (i -> m r) -> ChoiceT r i m a -> m r
- choice :: [a] -> ChoiceT r i m a
- findFirst :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)
- findAll :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)
- listChoiceT :: Applicative m => ChoiceT [a] [a] m a -> m [a]
- listA :: Alternative f => [a] -> f a
- maybeChoiceT :: Applicative m => ChoiceT (Maybe a) (Maybe a) m a -> m (Maybe a)
- newtype EitherT r e m a = EitherT {
- getEitherT :: (a -> m r) -> (e -> m r) -> m r
- runEitherT :: (a -> m r) -> (e -> m r) -> EitherT r e m a -> m r
- evalEitherT :: Applicative m => EitherT (Either e a) e m a -> m (Either e a)
- modifyEitherT :: Functor m => (r -> r) -> EitherT r e m ()
- newtype StateT r s m a = StateT {
- getStateT :: s -> (s -> a -> m r) -> m r
- runStateT :: s -> (s -> a -> m r) -> StateT r s m a -> m r
- evalStateT :: Applicative m => s -> StateT r s m r -> m r
- execStateT :: Applicative m => s -> StateT s s m a -> m s
- type WriterT = ContT
- runWriterT :: Alternative m => WriterT r m a -> m r
- type OldWriterT r w m a = ContT (r, w) m a
- runOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m (r, w)
- evalOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m r
- execOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m w
- newtype Id a = Id {
- getId :: a
- type Choice r i a = ChoiceT r i Id a
- listChoice :: Choice [a] [a] a -> [a]
- maybeChoice :: Choice (Maybe a) (Maybe a) a -> Maybe a
- type Cont r a = ContT r Id a
- runCont :: (a -> r) -> Cont r a -> r
- evalCont :: Cont r r -> r
- modifyCont :: (r -> r) -> Cont r ()
- type State r s a = StateT r s Id a
- runState :: s -> (s -> a -> r) -> State r s a -> r
- evalState :: s -> State r s r -> r
- execState :: s -> State s s a -> s
- type OldWriter r w a = ContT (r, w) Id a
- runOldWriter :: Monoid w => OldWriter r w r -> (r, w)
- evalOldWriter :: Monoid w => OldWriter r w r -> r
- execOldWriter :: Monoid w => OldWriter r w r -> w
- class Abortable m where
- class CallCC m where
- callCC :: ((a -> m b) -> m a) -> m a
- data Label m a
- labelCC :: (Applicative m, CallCC m) => a -> m (a, Label m a)
- goto :: Label m a -> a -> m ()
- class HasExceptions m where
- catch :: (HasExceptions m, Monad m) => m a -> (Exception m -> m a) -> m a
- handle :: (HasExceptions m, Monad m) => (Exception m -> m a) -> m a -> m a
- finally :: (HasExceptions m, Monad m) => m a -> m b -> m a
- bracket :: (HasExceptions m, Monad m) => m res -> (res -> m b) -> (res -> m a) -> m a
- bracket_ :: (HasExceptions m, Monad m) => m a -> m b -> m c -> m c
- class Transformer t where
- class LiftBase m a where
- io :: (LiftBase m a, Base m a ~ IO a) => Base m a -> m a
- class Runnable t r m a where
- class Stateful m where
- getField :: (Functor m, Stateful m) => (StateOf m -> a) -> m a
- modify :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()
- modifyField :: (Monad m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()
- modifyFieldLazy :: (Monad m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()
- modifyLazy :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()
- class Writable m w where
- module Control.Applicative
- module Control.Monad
Monad transformers
Identity transformer
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.
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 a, Monad m) => LiftBase (IdT m) a |
ContT
The continuation passing style monad transformer. This monad transformer models the most basic form of CPS.
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) | |
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 rSource
Run a CPS-style computation given the supplied final continuation.
evalContT :: Applicative m => ContT r m r -> m rSource
Evaluate a CPS-style computation to its final result.
modifyContT :: Functor m => (r -> r) -> ContT r m ()Source
Transform the final result along the way.
Choice/nondeterminism
newtype ChoiceT r i m a Source
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.
ChoiceT | |
|
runChoiceT :: (i -> a -> (i -> m r) -> m r) -> i -> (i -> m r) -> ChoiceT r i m a -> m rSource
Run a choice computation.
findFirst :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)Source
Find the first solution.
findAll :: (Alternative f, Applicative m) => ChoiceT (f a) (f a) m a -> m (f a)Source
Find all solutions.
listChoiceT :: Applicative m => ChoiceT [a] [a] m a -> m [a]Source
Get list of solutions (faster than findAll
, but returns solutions
in reversed order).
listA :: Alternative f => [a] -> f aSource
Turn a list into a computation with alternatives.
maybeChoiceT :: Applicative m => ChoiceT (Maybe a) (Maybe a) m a -> m (Maybe a)Source
Get one solution (faster than findFirst
).
Exceptions
newtype EitherT r e m a Source
Monad transformer for CPS computations with an additional exception continuation.
EitherT | |
|
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) | |
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 rSource
Run an EitherT
transformer.
evalEitherT :: Applicative m => EitherT (Either e a) e m a -> m (Either e a)Source
modifyEitherT :: Functor m => (r -> r) -> EitherT r e m ()Source
Modify the result of an EitherT
computation along the way.
State
Monad transformer for stateful computations.
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) | |
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 |
evalStateT :: Applicative m => s -> StateT r s m r -> m rSource
Run a state transformer returning its result.
execStateT :: Applicative m => s -> StateT s s m a -> m sSource
Run a state transformer returning its final state.
Writer monads
runWriterT :: Alternative m => WriterT r m a -> m rSource
Run a writer transformer.
type OldWriterT r w m a = ContT (r, w) m aSource
The traditional writer monad transformer.
runOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m (r, w)Source
Run a traditional writer transformer.
evalOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m rSource
Run a traditional writer transformer and return its result.
execOldWriterT :: (Applicative m, Monoid w) => OldWriterT r w m r -> m wSource
Run a traditional writer transformer and return its log.
Monads
Identity monad
The identity monad. This monad represents values themselves, i.e. computations without effects.
Choice
listChoice :: Choice [a] [a] a -> [a]Source
Get list of solutions.
Cont
modifyCont :: (r -> r) -> Cont r ()Source
Modify the result of a CPS computation along the way.
State
Writer
runOldWriter :: Monoid w => OldWriter r w r -> (r, w)Source
Run a traditional writer computation.
evalOldWriter :: Monoid w => OldWriter r w r -> rSource
Run a traditional writer computation and return its result.
execOldWriter :: Monoid w => OldWriter r w r -> wSource
Run a traditional writer computation and return its log.
Effect classes
Abortion
Monads supporting abortion.
Applicative m => Abortable (ContT r m) | |
Applicative m => Abortable (StateT r s m) | |
Applicative m => Abortable (EitherT r e m) |
Call with current continuation
Monads supporting *call-with-current-continuation* (aka callCC).
labelCC :: (Applicative m, CallCC m) => a -> m (a, Label m a)Source
Capture the current continuation for later use.
Exceptions
class HasExceptions m whereSource
Monads with exception support.
raise :: Exception m -> m aSource
Raise an exception.
try :: m a -> m (Either (Exception m) a)Source
Run computation catching exceptions.
HasExceptions IO | |
HasExceptions Maybe | |
HasExceptions (Either e) | |
HasExceptions (EitherT r e m) |
catch :: (HasExceptions m, Monad m) => m a -> (Exception m -> m a) -> m aSource
Catch exceptions using an exception handler.
handle :: (HasExceptions m, Monad m) => (Exception m -> m a) -> m a -> m aSource
Catch exceptions using an exception handler (flip catch
).
finally :: (HasExceptions m, Monad m) => m a -> m b -> m aSource
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 aSource
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 cSource
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 whereSource
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.
Transformer IdT | |
Transformer (ContT r) | |
Transformer (StateT r s) | |
Transformer (EitherT r e) | |
Transformer (ChoiceT r i) |
class LiftBase m a whereSource
Monads, which support lifting base monad computations.
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 aSource
Handy alias for lifting IO computations.
Running
class Runnable t r m a whereSource
Every monad transformer t
that supports transforming t m a
to
m a
can be an instance of this class.
State
modify :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()Source
Apply a function to the current state.
modifyField :: (Monad m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()Source
Get a field and modify the state.
modifyFieldLazy :: (Monad m, Stateful m) => (StateOf m -> a) -> (a -> StateOf m) -> m ()Source
Get a field and modify the state. Lazy version.
modifyLazy :: (Monad m, Stateful m) => (StateOf m -> StateOf m) -> m ()Source
Apply a function to the current state. Lazy version.
Logging support (writers)
class Writable m w whereSource
Monads with support for logging. Traditionally these are called *writer monads*.
Module reexports
module Control.Applicative
module Control.Monad