monadLib-3.4.4: A collection of monad transformers.Source codeContentsIndex
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)
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 Source
Computations with no effects.
show/hide Instances
data Lift a Source
Computation with no effects (strict).
show/hide Instances
data IdT m a Source
Adds no new features. Useful as a placeholder.
show/hide Instances
MonadT IdT
Monad m => Monad (IdT m)
Monad m => Functor (IdT m)
MonadFix m => MonadFix (IdT m)
MonadPlus m => MonadPlus (IdT m)
Monad m => Applicative (IdT m)
MonadPlus m => Alternative (IdT m)
ContM m => ContM (IdT m)
RunReaderM m j => RunReaderM (IdT m) j
RunWriterM m j => RunWriterM (IdT m) j
RunExceptionM m i => RunExceptionM (IdT m) i
ExceptionM m j => ExceptionM (IdT m) j
StateM m j => StateM (IdT m) j
WriterM m j => WriterM (IdT m) j
ReaderM m j => ReaderM (IdT m) j
BaseM m n => BaseM (IdT m) n
data ReaderT i m a Source
Add support for propagating a context of type i.
show/hide Instances
data WriterT i m a Source
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)
(Monad m, Monoid i) => Monad (WriterT i m)
(Monad m, Monoid i) => Functor (WriterT i m)
(MonadFix m, Monoid i) => MonadFix (WriterT i m)
(MonadPlus m, Monoid i) => MonadPlus (WriterT i m)
(Monad m, Monoid i) => Applicative (WriterT i m)
(MonadPlus m, Monoid i) => Alternative (WriterT i m)
(ContM m, Monoid i) => ContM (WriterT i m)
(RunReaderM m j, Monoid i) => RunReaderM (WriterT i m) j
(Monad m, Monoid i) => RunWriterM (WriterT i m) i
(RunExceptionM m i, Monoid j) => RunExceptionM (WriterT j m) i
(ExceptionM m j, Monoid i) => ExceptionM (WriterT i m) j
(StateM m j, Monoid i) => StateM (WriterT i m) j
(Monad m, Monoid i) => WriterM (WriterT i m) i
(ReaderM m j, Monoid i) => ReaderM (WriterT i m) j
(BaseM m n, Monoid i) => BaseM (WriterT i m) n
data StateT i m a Source
Add support for threading state of type i.
show/hide Instances
MonadT (StateT i)
Monad m => Monad (StateT i m)
Monad m => Functor (StateT i m)
MonadFix m => MonadFix (StateT i m)
MonadPlus m => MonadPlus (StateT i m)
Monad m => Applicative (StateT i m)
MonadPlus m => Alternative (StateT i m)
ContM m => ContM (StateT i m)
RunReaderM m j => RunReaderM (StateT i m) j
RunWriterM m j => RunWriterM (StateT i m) j
RunExceptionM m i => RunExceptionM (StateT j m) i
ExceptionM m j => ExceptionM (StateT i m) j
Monad m => StateM (StateT i m) i
WriterM m j => WriterM (StateT i m) j
ReaderM m j => ReaderM (StateT i m) j
BaseM m n => BaseM (StateT i m) n
data ExceptionT i m a Source
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 Source
Add support for multiple answers.
show/hide Instances
data ContT i m a Source
Add support for continuations within a prompt of type i.
show/hide Instances
MonadT (ContT i)
Monad m => Monad (ContT i m)
Monad m => Functor (ContT i m)
MonadPlus m => MonadPlus (ContT i m)
Monad m => Applicative (ContT i m)
MonadPlus m => Alternative (ContT i m)
Monad m => ContM (ContT i m)
ExceptionM m j => ExceptionM (ContT i m) j
StateM m j => StateM (ContT i m) j
WriterM m j => WriterM (ContT i m) j
ReaderM m j => ReaderM (ContT i m) j
BaseM m n => BaseM (ContT i m) n
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 whereSource
Methods
lift :: Monad m => m a -> t m aSource
Promote a computation from the underlying monad.
show/hide Instances
class (Monad m, Monad n) => BaseM m n | m -> n whereSource
Methods
inBase :: n a -> m aSource
Promote a computation from the base monad.
show/hide Instances
BaseM IO IO
BaseM Maybe Maybe
BaseM Lift Lift
BaseM Id Id
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 (State i) (State i)
BaseM (Reader i) (Reader 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 (StateT i m) n
(BaseM m n, Monoid i) => BaseM (WriterT i m) n
BaseM m n => BaseM (ReaderT 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 whereSource
Classifies monads that provide access to a context of type i.
Methods
ask :: m iSource
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
ReaderM m j => ReaderM (StateT i m) j
(ReaderM m j, Monoid i) => ReaderM (WriterT i m) j
Monad m => ReaderM (ReaderT i m) i
class Monad m => WriterM m i | m -> i whereSource
Classifies monads that can collect values of type i.
Methods
put :: i -> m ()Source
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 (StateT i m) j
(Monad m, Monoid i) => WriterM (WriterT i m) i
WriterM m j => WriterM (ReaderT i m) j
class Monad m => StateM m i | m -> i whereSource
Classifies monads that propagate a state component of type i.
Methods
get :: m iSource
Get the state.
set :: i -> m ()Source
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
Monad m => StateM (StateT i m) i
(StateM m j, Monoid i) => StateM (WriterT i m) j
StateM m j => StateM (ReaderT i m) j
class Monad m => ExceptionM m i | m -> i whereSource
Classifies monads that support raising exceptions of type i.
Methods
raise :: i -> m aSource
Raise an exception.
show/hide Instances
class Monad m => ContM m whereSource
Classifies monads that provide access to a computation's continuation.
Methods
callCC :: ((a -> m b) -> m a) -> m aSource
Capture the current continuation.
show/hide Instances
ContM m => ContM (ChoiceT m)
ContM m => ContM (IdT m)
ContM (Cont i)
Monad m => ContM (ContT i m)
ContM m => ContM (ExceptionT i m)
ContM m => ContM (StateT i m)
(ContM m, Monoid i) => ContM (WriterT i m)
ContM m => ContM (ReaderT i m)
data Label m a Source
An explicit representation for continuations that store a value.
labelCC :: ContM m => a -> m (a, Label m a)Source
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 bSource
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 -> aSource
Get the result of a pure computation.
runLift :: Lift a -> aSource
Get the result of a pure strict computation.
runIdT :: IdT m a -> m aSource
Remove an identity layer.
runReaderT :: i -> ReaderT i m a -> m aSource
Execute a reader computation in the given context.
runWriterT :: Monad m => WriterT i m a -> m (a, i)Source
Execute a writer computation. Returns the result and the collected output.
runStateT :: i -> StateT i m a -> m (a, i)Source
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)Source
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 iSource
Execute a computation with the given continuation.
runChoiceT :: Monad m => ChoiceT m a -> m (Maybe (a, ChoiceT m a))Source
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)Source
Execute a computation that may return multiple answers, returning at most one answer.
findAll :: Monad m => ChoiceT m a -> m [a]Source
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 whereSource
Classifies monads that support changing the context for a sub-computation.
Methods
local :: i -> m a -> m aSource
Change the context for the duration of a sub-computation.
show/hide Instances
class WriterM m i => RunWriterM m i | m -> i whereSource
Classifies monads that support collecting the output of a sub-computation.
Methods
collect :: m a -> m (a, i)Source
Collect the output from a sub-computation.
show/hide Instances
class ExceptionM m i => RunExceptionM m i | m -> i whereSource
Classifies monads that support handling of exceptions.
Methods
try :: m a -> m (Either i a)Source
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)Source
The current version of the library.
Produced by Haddock version 2.1.0