monadLib-3.4.4: A collection of monad transformers.ContentsIndex
MonadLib
Contents
Types
Lifting
Effect Classes
Execution
Eliminating Effects
Nested Execution
Miscellaneous
Description
This library provides a collection of monad transformers that can be combined to produce various monads.
Synopsis
data Id a
data Lift a
data IdT m a
data ReaderT i m a
data WriterT i m a
data StateT i m a
data ExceptionT i m a
data ChoiceT m a
data ContT i m a
class MonadT t where
lift :: Monad m => m a -> t m a
class (Monad m, Monad n) => BaseM m n | m -> n where
inBase :: n a -> m a
class Monad m => ReaderM m i | m -> i where
ask :: m i
class Monad m => WriterM m i | m -> i where
put :: i -> m ()
class Monad m => StateM m i | m -> i where
get :: m i
set :: i -> m ()
class Monad m => ExceptionM m i | m -> i where
raise :: i -> m a
class Monad m => ContM m where
callCC :: ((a -> m b) -> m a) -> m a
data Label m a
labelCC :: ContM m => a -> m (a, Label m a)
jump :: ContM m => a -> Label m a -> m b
runId :: Id a -> a
runLift :: Lift a -> a
runIdT :: IdT m a -> m a
runReaderT :: i -> ReaderT i m a -> m a
runWriterT :: Monad m => WriterT i m a -> m (a, i)
runStateT :: i -> StateT i m a -> m (a, i)
runExceptionT :: ExceptionT i m a -> m (Either i a)
runContT :: (a -> m i) -> ContT i m a -> m i
runChoiceT :: Monad m => ChoiceT m a -> m (Maybe (a, ChoiceT m a))
findOne :: Monad m => ChoiceT m a -> m (Maybe a)
findAll :: Monad m => ChoiceT m a -> m [a]
class ReaderM m i => RunReaderM m i | m -> i where
local :: i -> m a -> m a
class WriterM m i => RunWriterM m i | m -> i where
collect :: m a -> m (a, i)
class ExceptionM m i => RunExceptionM m i | m -> i where
try :: m a -> m (Either i a)
version :: (Int, Int, Int)
module Control.Monad
Types
The following types define the representations of the computation types supported by the library. Each type adds support for a different effect.
data Id a
Computations with no effects.
show/hide Instances
data Lift a
Computation with no effects (strict).
show/hide Instances
data IdT m a
Adds no new features. Useful as a placeholder.
show/hide Instances
MonadT IdT
MonadPlus m => Alternative (IdT m)
Monad m => Applicative (IdT m)
ContM m => ContM (IdT m)
Monad m => Functor (IdT m)
Monad m => Monad (IdT m)
MonadFix m => MonadFix (IdT m)
MonadPlus m => MonadPlus (IdT m)
BaseM m n => BaseM (IdT m) n
ExceptionM m j => ExceptionM (IdT m) j
ReaderM m j => ReaderM (IdT m) j
RunExceptionM m i => RunExceptionM (IdT m) i
RunReaderM m j => RunReaderM (IdT m) j
RunWriterM m j => RunWriterM (IdT m) j
StateM m j => StateM (IdT m) j
WriterM m j => WriterM (IdT m) j
data ReaderT i m a
Add support for propagating a context of type i.
show/hide Instances
data WriterT i m a
Add support for collecting values of type i. The type i should be a monoid, whose unit is used to represent a lack of a value, and whose binary operation is used to combine multiple values. This transformer is strict in its output component.
show/hide Instances
Monoid i => MonadT (WriterT i)
(MonadPlus m, Monoid i) => Alternative (WriterT i m)
(Monad m, Monoid i) => Applicative (WriterT i m)
(ContM m, Monoid i) => ContM (WriterT i m)
(Monad m, Monoid i) => Functor (WriterT i m)
(Monad m, Monoid i) => Monad (WriterT i m)
(MonadFix m, Monoid i) => MonadFix (WriterT i m)
(MonadPlus m, Monoid i) => MonadPlus (WriterT i m)
(BaseM m n, Monoid i) => BaseM (WriterT i m) n
(ExceptionM m j, Monoid i) => ExceptionM (WriterT i m) j
(ReaderM m j, Monoid i) => ReaderM (WriterT i m) j
(RunExceptionM m i, Monoid j) => RunExceptionM (WriterT j m) i
(RunReaderM m j, Monoid i) => RunReaderM (WriterT i m) j
(Monad m, Monoid i) => RunWriterM (WriterT i m) i
(StateM m j, Monoid i) => StateM (WriterT i m) j
(Monad m, Monoid i) => WriterM (WriterT i m) i
data StateT i m a
Add support for threading state of type i.
show/hide Instances
MonadT (StateT i)
MonadPlus m => Alternative (StateT i m)
Monad m => Applicative (StateT i m)
ContM m => ContM (StateT i m)
Monad m => Functor (StateT i m)
Monad m => Monad (StateT i m)
MonadFix m => MonadFix (StateT i m)
MonadPlus m => MonadPlus (StateT i m)
BaseM m n => BaseM (StateT i m) n
ExceptionM m j => ExceptionM (StateT i m) j
ReaderM m j => ReaderM (StateT i m) j
RunExceptionM m i => RunExceptionM (StateT j m) i
RunReaderM m j => RunReaderM (StateT i m) j
RunWriterM m j => RunWriterM (StateT i m) j
Monad m => StateM (StateT i m) i
WriterM m j => WriterM (StateT i m) j
data ExceptionT i m a
Add support for exceptions of type i.
show/hide Instances

About the WriterM instance: If an exception is risen while we are collecting output, then the output is lost. If the output is important, then use try to ensure that no exception may occur. Example: 

 do (r,w) <- collect (try m)
    case r of
      Left err -> ...do something...
      Right a  -> ...do something...
data ChoiceT m a
Add support for multiple answers.
show/hide Instances
data ContT i m a
Add support for continuations within a prompt of type i.
show/hide Instances
MonadT (ContT i)
MonadPlus m => Alternative (ContT i m)
Monad m => Applicative (ContT i m)
Monad m => ContM (ContT i m)
Monad m => Functor (ContT i m)
Monad m => Monad (ContT i m)
MonadPlus m => MonadPlus (ContT i m)
BaseM m n => BaseM (ContT i m) n
ExceptionM m j => ExceptionM (ContT i m) j
ReaderM m j => ReaderM (ContT i m) j
StateM m j => StateM (ContT i m) j
WriterM m j => WriterM (ContT i m) j
Lifting
The following operations allow us to promote computations in the underlying monad to computations that support an extra effect. Computations defined in this way do not make use of the new effect but can be combined with other operations that utilize the effect.
class MonadT t where
Methods
lift :: Monad m => m a -> t m a
Promote a computation from the underlying monad.
show/hide Instances
class (Monad m, Monad n) => BaseM m n | m -> n where
Methods
inBase :: n a -> m a
Promote a computation from the base monad.
show/hide Instances
BaseM IO IO
BaseM Id Id
BaseM Lift Lift
BaseM Maybe Maybe
BaseM [] []
BaseM m n => BaseM (ChoiceT m) n
BaseM m n => BaseM (IdT m) n
BaseM (Cont i) (Cont i)
BaseM (Exception i) (Exception i)
BaseM (Reader i) (Reader i)
BaseM (State i) (State i)
Monoid i => BaseM (Writer i) (Writer i)
BaseM m n => BaseM (ContT i m) n
BaseM m n => BaseM (ExceptionT i m) n
BaseM m n => BaseM (ReaderT i m) n
BaseM m n => BaseM (StateT i m) n
(BaseM m n, Monoid i) => BaseM (WriterT i m) n
Effect Classes
The following classes define overloaded operations that can be used to define effectful computations.
class Monad m => ReaderM m i | m -> i where
Classifies monads that provide access to a context of type i.
Methods
ask :: m i
Get the context.
show/hide Instances
ReaderM m j => ReaderM (ChoiceT m) j
ReaderM m j => ReaderM (IdT m) j
ReaderM (Reader i) i
ReaderM m j => ReaderM (ContT i m) j
ReaderM m j => ReaderM (ExceptionT i m) j
Monad m => ReaderM (ReaderT i m) i
ReaderM m j => ReaderM (StateT i m) j
(ReaderM m j, Monoid i) => ReaderM (WriterT i m) j
class Monad m => WriterM m i | m -> i where
Classifies monads that can collect values of type i.
Methods
put :: i -> m ()
Add a value to the collection.
show/hide Instances
WriterM m j => WriterM (ChoiceT m) j
WriterM m j => WriterM (IdT m) j
Monoid i => WriterM (Writer i) i
WriterM m j => WriterM (ContT i m) j
WriterM m j => WriterM (ExceptionT i m) j
WriterM m j => WriterM (ReaderT i m) j
WriterM m j => WriterM (StateT i m) j
(Monad m, Monoid i) => WriterM (WriterT i m) i
class Monad m => StateM m i | m -> i where
Classifies monads that propagate a state component of type i.
Methods
get :: m i
Get the state.
set :: i -> m ()
Set the state.
show/hide Instances
StateM m j => StateM (ChoiceT m) j
StateM m j => StateM (IdT m) j
StateM (State i) i
StateM m j => StateM (ContT i m) j
StateM m j => StateM (ExceptionT i m) j
StateM m j => StateM (ReaderT i m) j
Monad m => StateM (StateT i m) i
(StateM m j, Monoid i) => StateM (WriterT i m) j
class Monad m => ExceptionM m i | m -> i where
Classifies monads that support raising exceptions of type i.
Methods
raise :: i -> m a
Raise an exception.
show/hide Instances
class Monad m => ContM m where
Classifies monads that provide access to a computation's continuation.
Methods
callCC :: ((a -> m b) -> m a) -> m a
Capture the current continuation.
show/hide Instances
ContM m => ContM (ChoiceT m)
ContM (Cont i)
ContM m => ContM (IdT m)
Monad m => ContM (ContT i m)
ContM m => ContM (ExceptionT i m)
ContM m => ContM (ReaderT i m)
ContM m => ContM (StateT i m)
(ContM m, Monoid i) => ContM (WriterT i m)
data Label m a
An explicit representation for continuations that store a value.
labelCC :: ContM m => a -> m (a, Label m a)
Capture the current continuation. This function is like return, except that it also captures the current continuation. Later, we can use jump to repeat the computation from this point onwards but with a possibly different value.
jump :: ContM m => a -> Label m a -> m b
Change the value passed to a previously captured continuation.
Execution
Eliminating Effects
The following functions eliminate the outermost effect of a computation by translating a computation into an equivalent computation in the underlying monad. (The exceptions are Id and Lift which are not transformers but ordinary monas and so, their run operations simply eliminate the monad.)
runId :: Id a -> a
Get the result of a pure computation.
runLift :: Lift a -> a
Get the result of a pure strict computation.
runIdT :: IdT m a -> m a
Remove an identity layer.
runReaderT :: i -> ReaderT i m a -> m a
Execute a reader computation in the given context.
runWriterT :: Monad m => WriterT i m a -> m (a, i)
Execute a writer computation. Returns the result and the collected output.
runStateT :: i -> StateT i m a -> m (a, i)
Execute a stateful computation in the given initial state. The second component of the result is the final state.
runExceptionT :: ExceptionT i m a -> m (Either i a)
Execute a computation with exceptions. Successful results are tagged with Right, exceptional results are tagged with Left.
runContT :: (a -> m i) -> ContT i m a -> m i
Execute a computation with the given continuation.
runChoiceT :: Monad m => ChoiceT m a -> m (Maybe (a, ChoiceT m a))
Execute a computation that may return multiple answers. The resulting computation returns Nothing if no answers were found, or Just (answer,new_comp), where answer is an answer, and new_comp is a computation that may produce more answers. The search is depth-first and left-biased with respect to the mplus operation.
findOne :: Monad m => ChoiceT m a -> m (Maybe a)
Execute a computation that may return multiple answers, returning at most one answer.
findAll :: Monad m => ChoiceT m a -> m [a]
Executie a computation that may return multiple answers, collecting all possible answers.
Nested Execution
The following classes define operations that are overloaded versions of the run operations. Unlike the run operations, these functions do not change the type of the computation (i.e, they do not remove a layer). Instead, they perform the effects in a ``separate effect thread''.
class ReaderM m i => RunReaderM m i | m -> i where
Classifies monads that support changing the context for a sub-computation.
Methods
local :: i -> m a -> m a
Change the context for the duration of a sub-computation.
show/hide Instances
class WriterM m i => RunWriterM m i | m -> i where
Classifies monads that support collecting the output of a sub-computation.
Methods
collect :: m a -> m (a, i)
Collect the output from a sub-computation.
show/hide Instances
class ExceptionM m i => RunExceptionM m i | m -> i where
Classifies monads that support handling of exceptions.
Methods
try :: m a -> m (Either i a)
Convert computations that may raise an exception into computations that do not raise exception but instead, yield a tagged results. Exceptions are tagged with Left, successful computations are tagged with Right.
show/hide Instances
Miscellaneous
version :: (Int, Int, Int)
The current version of the library.
module Control.Monad
Produced by Haddock version 0.8