monadLib-3.7.3: A collection of monad transformers.

Safe HaskellTrustworthy
LanguageHaskell98

MonadLib

Contents

Description

This library provides a collection of monad transformers that can be combined to produce various monads.

Synopsis

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.

Instances

Monad Id Source # 

Methods

(>>=) :: Id a -> (a -> Id b) -> Id b #

(>>) :: Id a -> Id b -> Id b #

return :: a -> Id a #

fail :: String -> Id a #

Functor Id Source # 

Methods

fmap :: (a -> b) -> Id a -> Id b #

(<$) :: a -> Id b -> Id a #

MonadFix Id Source # 

Methods

mfix :: (a -> Id a) -> Id a #

Applicative Id Source # 

Methods

pure :: a -> Id a #

(<*>) :: Id (a -> b) -> Id a -> Id b #

liftA2 :: (a -> b -> c) -> Id a -> Id b -> Id c #

(*>) :: Id a -> Id b -> Id b #

(<*) :: Id a -> Id b -> Id a #

BaseM Id Id Source # 

Methods

inBase :: Id a -> Id a Source #

RunM Id a a Source # 

Methods

runM :: Id a -> a Source #

data Lift a Source #

Computation with no effects (strict).

Instances

Monad Lift Source # 

Methods

(>>=) :: Lift a -> (a -> Lift b) -> Lift b #

(>>) :: Lift a -> Lift b -> Lift b #

return :: a -> Lift a #

fail :: String -> Lift a #

Functor Lift Source # 

Methods

fmap :: (a -> b) -> Lift a -> Lift b #

(<$) :: a -> Lift b -> Lift a #

MonadFix Lift Source # 

Methods

mfix :: (a -> Lift a) -> Lift a #

Applicative Lift Source # 

Methods

pure :: a -> Lift a #

(<*>) :: Lift (a -> b) -> Lift a -> Lift b #

liftA2 :: (a -> b -> c) -> Lift a -> Lift b -> Lift c #

(*>) :: Lift a -> Lift b -> Lift b #

(<*) :: Lift a -> Lift b -> Lift a #

BaseM Lift Lift Source # 

Methods

inBase :: Lift a -> Lift a Source #

RunM Lift a a Source # 

Methods

runM :: Lift a -> a Source #

data IdT m a Source #

Adds no new features. Useful as a placeholder.

Instances

MonadT IdT Source # 

Methods

lift :: Monad m => m a -> IdT m a Source #

Monad m => Monad (IdT m) Source # 

Methods

(>>=) :: IdT m a -> (a -> IdT m b) -> IdT m b #

(>>) :: IdT m a -> IdT m b -> IdT m b #

return :: a -> IdT m a #

fail :: String -> IdT m a #

Monad m => Functor (IdT m) Source # 

Methods

fmap :: (a -> b) -> IdT m a -> IdT m b #

(<$) :: a -> IdT m b -> IdT m a #

MonadFix m => MonadFix (IdT m) Source # 

Methods

mfix :: (a -> IdT m a) -> IdT m a #

Monad m => Applicative (IdT m) Source # 

Methods

pure :: a -> IdT m a #

(<*>) :: IdT m (a -> b) -> IdT m a -> IdT m b #

liftA2 :: (a -> b -> c) -> IdT m a -> IdT m b -> IdT m c #

(*>) :: IdT m a -> IdT m b -> IdT m b #

(<*) :: IdT m a -> IdT m b -> IdT m a #

MonadPlus m => Alternative (IdT m) Source # 

Methods

empty :: IdT m a #

(<|>) :: IdT m a -> IdT m a -> IdT m a #

some :: IdT m a -> IdT m [a] #

many :: IdT m a -> IdT m [a] #

MonadPlus m => MonadPlus (IdT m) Source # 

Methods

mzero :: IdT m a #

mplus :: IdT m a -> IdT m a -> IdT m a #

ContM m => ContM (IdT m) Source # 

Methods

callWithCC :: ((a -> Label (IdT m)) -> IdT m a) -> IdT m a Source #

AbortM m i => AbortM (IdT m) i Source # 

Methods

abort :: i -> IdT m a Source #

RunExceptionM m i => RunExceptionM (IdT m) i Source # 

Methods

try :: IdT m a -> IdT m (Either i a) Source #

RunWriterM m j => RunWriterM (IdT m) j Source # 

Methods

collect :: IdT m a -> IdT m (a, j) Source #

RunReaderM m j => RunReaderM (IdT m) j Source # 

Methods

local :: j -> IdT m a -> IdT m a Source #

ExceptionM m j => ExceptionM (IdT m) j Source # 

Methods

raise :: j -> IdT m a Source #

StateM m j => StateM (IdT m) j Source # 

Methods

get :: IdT m j Source #

set :: j -> IdT m () Source #

WriterM m j => WriterM (IdT m) j Source # 

Methods

put :: j -> IdT m () Source #

ReaderM m j => ReaderM (IdT m) j Source # 

Methods

ask :: IdT m j Source #

BaseM m n => BaseM (IdT m) n Source # 

Methods

inBase :: n a -> IdT m a Source #

RunM m a r => RunM (IdT m) a r Source # 

Methods

runM :: IdT m a -> r Source #

data ReaderT i m a Source #

Add support for propagating a context of type i.

Instances

MonadT (ReaderT i) Source # 

Methods

lift :: Monad m => m a -> ReaderT i m a Source #

Monad m => Monad (ReaderT i m) Source # 

Methods

(>>=) :: ReaderT i m a -> (a -> ReaderT i m b) -> ReaderT i m b #

(>>) :: ReaderT i m a -> ReaderT i m b -> ReaderT i m b #

return :: a -> ReaderT i m a #

fail :: String -> ReaderT i m a #

Monad m => Functor (ReaderT i m) Source # 

Methods

fmap :: (a -> b) -> ReaderT i m a -> ReaderT i m b #

(<$) :: a -> ReaderT i m b -> ReaderT i m a #

MonadFix m => MonadFix (ReaderT i m) Source # 

Methods

mfix :: (a -> ReaderT i m a) -> ReaderT i m a #

Monad m => Applicative (ReaderT i m) Source # 

Methods

pure :: a -> ReaderT i m a #

(<*>) :: ReaderT i m (a -> b) -> ReaderT i m a -> ReaderT i m b #

liftA2 :: (a -> b -> c) -> ReaderT i m a -> ReaderT i m b -> ReaderT i m c #

(*>) :: ReaderT i m a -> ReaderT i m b -> ReaderT i m b #

(<*) :: ReaderT i m a -> ReaderT i m b -> ReaderT i m a #

MonadPlus m => Alternative (ReaderT i m) Source # 

Methods

empty :: ReaderT i m a #

(<|>) :: ReaderT i m a -> ReaderT i m a -> ReaderT i m a #

some :: ReaderT i m a -> ReaderT i m [a] #

many :: ReaderT i m a -> ReaderT i m [a] #

MonadPlus m => MonadPlus (ReaderT i m) Source # 

Methods

mzero :: ReaderT i m a #

mplus :: ReaderT i m a -> ReaderT i m a -> ReaderT i m a #

ContM m => ContM (ReaderT i m) Source # 

Methods

callWithCC :: ((a -> Label (ReaderT i m)) -> ReaderT i m a) -> ReaderT i m a Source #

AbortM m i => AbortM (ReaderT j m) i Source # 

Methods

abort :: i -> ReaderT j m a Source #

RunExceptionM m i => RunExceptionM (ReaderT j m) i Source # 

Methods

try :: ReaderT j m a -> ReaderT j m (Either i a) Source #

RunWriterM m j => RunWriterM (ReaderT i m) j Source # 

Methods

collect :: ReaderT i m a -> ReaderT i m (a, j) Source #

Monad m => RunReaderM (ReaderT i m) i Source # 

Methods

local :: i -> ReaderT i m a -> ReaderT i m a Source #

ExceptionM m j => ExceptionM (ReaderT i m) j Source # 

Methods

raise :: j -> ReaderT i m a Source #

StateM m j => StateM (ReaderT i m) j Source # 

Methods

get :: ReaderT i m j Source #

set :: j -> ReaderT i m () Source #

WriterM m j => WriterM (ReaderT i m) j Source # 

Methods

put :: j -> ReaderT i m () Source #

Monad m => ReaderM (ReaderT i m) i Source # 

Methods

ask :: ReaderT i m i Source #

BaseM m n => BaseM (ReaderT i m) n Source # 

Methods

inBase :: n a -> ReaderT i m a Source #

RunM m a r => RunM (ReaderT i m) a (i -> r) Source # 

Methods

runM :: ReaderT i m a -> i -> r Source #

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.

Instances

Monoid i => MonadT (WriterT i) Source # 

Methods

lift :: Monad m => m a -> WriterT i m a Source #

(Monad m, Monoid i) => Monad (WriterT i m) Source # 

Methods

(>>=) :: WriterT i m a -> (a -> WriterT i m b) -> WriterT i m b #

(>>) :: WriterT i m a -> WriterT i m b -> WriterT i m b #

return :: a -> WriterT i m a #

fail :: String -> WriterT i m a #

(Monad m, Monoid i) => Functor (WriterT i m) Source # 

Methods

fmap :: (a -> b) -> WriterT i m a -> WriterT i m b #

(<$) :: a -> WriterT i m b -> WriterT i m a #

(MonadFix m, Monoid i) => MonadFix (WriterT i m) Source # 

Methods

mfix :: (a -> WriterT i m a) -> WriterT i m a #

(Monad m, Monoid i) => Applicative (WriterT i m) Source # 

Methods

pure :: a -> WriterT i m a #

(<*>) :: WriterT i m (a -> b) -> WriterT i m a -> WriterT i m b #

liftA2 :: (a -> b -> c) -> WriterT i m a -> WriterT i m b -> WriterT i m c #

(*>) :: WriterT i m a -> WriterT i m b -> WriterT i m b #

(<*) :: WriterT i m a -> WriterT i m b -> WriterT i m a #

(MonadPlus m, Monoid i) => Alternative (WriterT i m) Source # 

Methods

empty :: WriterT i m a #

(<|>) :: WriterT i m a -> WriterT i m a -> WriterT i m a #

some :: WriterT i m a -> WriterT i m [a] #

many :: WriterT i m a -> WriterT i m [a] #

(MonadPlus m, Monoid i) => MonadPlus (WriterT i m) Source # 

Methods

mzero :: WriterT i m a #

mplus :: WriterT i m a -> WriterT i m a -> WriterT i m a #

(ContM m, Monoid i) => ContM (WriterT i m) Source # 

Methods

callWithCC :: ((a -> Label (WriterT i m)) -> WriterT i m a) -> WriterT i m a Source #

(AbortM m i, Monoid j) => AbortM (WriterT j m) i Source # 

Methods

abort :: i -> WriterT j m a Source #

(RunExceptionM m i, Monoid j) => RunExceptionM (WriterT j m) i Source # 

Methods

try :: WriterT j m a -> WriterT j m (Either i a) Source #

(Monad m, Monoid i) => RunWriterM (WriterT i m) i Source # 

Methods

collect :: WriterT i m a -> WriterT i m (a, i) Source #

(RunReaderM m j, Monoid i) => RunReaderM (WriterT i m) j Source # 

Methods

local :: j -> WriterT i m a -> WriterT i m a Source #

(ExceptionM m j, Monoid i) => ExceptionM (WriterT i m) j Source # 

Methods

raise :: j -> WriterT i m a Source #

(StateM m j, Monoid i) => StateM (WriterT i m) j Source # 

Methods

get :: WriterT i m j Source #

set :: j -> WriterT i m () Source #

(Monad m, Monoid i) => WriterM (WriterT i m) i Source # 

Methods

put :: i -> WriterT i m () Source #

(ReaderM m j, Monoid i) => ReaderM (WriterT i m) j Source # 

Methods

ask :: WriterT i m j Source #

(BaseM m n, Monoid i) => BaseM (WriterT i m) n Source # 

Methods

inBase :: n a -> WriterT i m a Source #

(Monoid i, RunM m (a, i) r) => RunM (WriterT i m) a r Source # 

Methods

runM :: WriterT i m a -> r Source #

data StateT i m a Source #

Add support for threading state of type i.

Instances

MonadT (StateT i) Source # 

Methods

lift :: Monad m => m a -> StateT i m a Source #

Monad m => Monad (StateT i m) Source # 

Methods

(>>=) :: StateT i m a -> (a -> StateT i m b) -> StateT i m b #

(>>) :: StateT i m a -> StateT i m b -> StateT i m b #

return :: a -> StateT i m a #

fail :: String -> StateT i m a #

Monad m => Functor (StateT i m) Source # 

Methods

fmap :: (a -> b) -> StateT i m a -> StateT i m b #

(<$) :: a -> StateT i m b -> StateT i m a #

MonadFix m => MonadFix (StateT i m) Source # 

Methods

mfix :: (a -> StateT i m a) -> StateT i m a #

Monad m => Applicative (StateT i m) Source # 

Methods

pure :: a -> StateT i m a #

(<*>) :: StateT i m (a -> b) -> StateT i m a -> StateT i m b #

liftA2 :: (a -> b -> c) -> StateT i m a -> StateT i m b -> StateT i m c #

(*>) :: StateT i m a -> StateT i m b -> StateT i m b #

(<*) :: StateT i m a -> StateT i m b -> StateT i m a #

MonadPlus m => Alternative (StateT i m) Source # 

Methods

empty :: StateT i m a #

(<|>) :: StateT i m a -> StateT i m a -> StateT i m a #

some :: StateT i m a -> StateT i m [a] #

many :: StateT i m a -> StateT i m [a] #

MonadPlus m => MonadPlus (StateT i m) Source # 

Methods

mzero :: StateT i m a #

mplus :: StateT i m a -> StateT i m a -> StateT i m a #

ContM m => ContM (StateT i m) Source # 

Methods

callWithCC :: ((a -> Label (StateT i m)) -> StateT i m a) -> StateT i m a Source #

AbortM m i => AbortM (StateT j m) i Source # 

Methods

abort :: i -> StateT j m a Source #

RunExceptionM m i => RunExceptionM (StateT j m) i Source # 

Methods

try :: StateT j m a -> StateT j m (Either i a) Source #

RunWriterM m j => RunWriterM (StateT i m) j Source # 

Methods

collect :: StateT i m a -> StateT i m (a, j) Source #

RunReaderM m j => RunReaderM (StateT i m) j Source # 

Methods

local :: j -> StateT i m a -> StateT i m a Source #

ExceptionM m j => ExceptionM (StateT i m) j Source # 

Methods

raise :: j -> StateT i m a Source #

Monad m => StateM (StateT i m) i Source # 

Methods

get :: StateT i m i Source #

set :: i -> StateT i m () Source #

WriterM m j => WriterM (StateT i m) j Source # 

Methods

put :: j -> StateT i m () Source #

ReaderM m j => ReaderM (StateT i m) j Source # 

Methods

ask :: StateT i m j Source #

BaseM m n => BaseM (StateT i m) n Source # 

Methods

inBase :: n a -> StateT i m a Source #

RunM m (a, i) r => RunM (StateT i m) a (i -> r) Source # 

Methods

runM :: StateT i m a -> i -> r Source #

data ExceptionT i m a Source #

Add support for exceptions of type i.

Instances

MonadT (ExceptionT i) Source # 

Methods

lift :: Monad m => m a -> ExceptionT i m a Source #

Monad m => Monad (ExceptionT i m) Source # 

Methods

(>>=) :: ExceptionT i m a -> (a -> ExceptionT i m b) -> ExceptionT i m b #

(>>) :: ExceptionT i m a -> ExceptionT i m b -> ExceptionT i m b #

return :: a -> ExceptionT i m a #

fail :: String -> ExceptionT i m a #

Monad m => Functor (ExceptionT i m) Source # 

Methods

fmap :: (a -> b) -> ExceptionT i m a -> ExceptionT i m b #

(<$) :: a -> ExceptionT i m b -> ExceptionT i m a #

MonadFix m => MonadFix (ExceptionT i m) Source # 

Methods

mfix :: (a -> ExceptionT i m a) -> ExceptionT i m a #

Monad m => Applicative (ExceptionT i m) Source # 

Methods

pure :: a -> ExceptionT i m a #

(<*>) :: ExceptionT i m (a -> b) -> ExceptionT i m a -> ExceptionT i m b #

liftA2 :: (a -> b -> c) -> ExceptionT i m a -> ExceptionT i m b -> ExceptionT i m c #

(*>) :: ExceptionT i m a -> ExceptionT i m b -> ExceptionT i m b #

(<*) :: ExceptionT i m a -> ExceptionT i m b -> ExceptionT i m a #

MonadPlus m => Alternative (ExceptionT i m) Source # 

Methods

empty :: ExceptionT i m a #

(<|>) :: ExceptionT i m a -> ExceptionT i m a -> ExceptionT i m a #

some :: ExceptionT i m a -> ExceptionT i m [a] #

many :: ExceptionT i m a -> ExceptionT i m [a] #

MonadPlus m => MonadPlus (ExceptionT i m) Source # 

Methods

mzero :: ExceptionT i m a #

mplus :: ExceptionT i m a -> ExceptionT i m a -> ExceptionT i m a #

ContM m => ContM (ExceptionT i m) Source # 

Methods

callWithCC :: ((a -> Label (ExceptionT i m)) -> ExceptionT i m a) -> ExceptionT i m a Source #

AbortM m i => AbortM (ExceptionT j m) i Source # 

Methods

abort :: i -> ExceptionT j m a Source #

Monad m => RunExceptionM (ExceptionT i m) i Source # 

Methods

try :: ExceptionT i m a -> ExceptionT i m (Either i a) Source #

RunWriterM m j => RunWriterM (ExceptionT i m) j Source # 

Methods

collect :: ExceptionT i m a -> ExceptionT i m (a, j) Source #

RunReaderM m j => RunReaderM (ExceptionT i m) j Source # 

Methods

local :: j -> ExceptionT i m a -> ExceptionT i m a Source #

Monad m => ExceptionM (ExceptionT i m) i Source # 

Methods

raise :: i -> ExceptionT i m a Source #

StateM m j => StateM (ExceptionT i m) j Source # 

Methods

get :: ExceptionT i m j Source #

set :: j -> ExceptionT i m () Source #

WriterM m j => WriterM (ExceptionT i m) j Source # 

Methods

put :: j -> ExceptionT i m () Source #

ReaderM m j => ReaderM (ExceptionT i m) j Source # 

Methods

ask :: ExceptionT i m j Source #

BaseM m n => BaseM (ExceptionT i m) n Source # 

Methods

inBase :: n a -> ExceptionT i m a Source #

RunM m (Either i a) r => RunM (ExceptionT i m) a r Source # 

Methods

runM :: ExceptionT i m a -> r Source #

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.

Instances

MonadT ChoiceT Source # 

Methods

lift :: Monad m => m a -> ChoiceT m a Source #

Monad m => Monad (ChoiceT m) Source # 

Methods

(>>=) :: ChoiceT m a -> (a -> ChoiceT m b) -> ChoiceT m b #

(>>) :: ChoiceT m a -> ChoiceT m b -> ChoiceT m b #

return :: a -> ChoiceT m a #

fail :: String -> ChoiceT m a #

Monad m => Functor (ChoiceT m) Source # 

Methods

fmap :: (a -> b) -> ChoiceT m a -> ChoiceT m b #

(<$) :: a -> ChoiceT m b -> ChoiceT m a #

Monad m => Applicative (ChoiceT m) Source # 

Methods

pure :: a -> ChoiceT m a #

(<*>) :: ChoiceT m (a -> b) -> ChoiceT m a -> ChoiceT m b #

liftA2 :: (a -> b -> c) -> ChoiceT m a -> ChoiceT m b -> ChoiceT m c #

(*>) :: ChoiceT m a -> ChoiceT m b -> ChoiceT m b #

(<*) :: ChoiceT m a -> ChoiceT m b -> ChoiceT m a #

Monad m => Alternative (ChoiceT m) Source # 

Methods

empty :: ChoiceT m a #

(<|>) :: ChoiceT m a -> ChoiceT m a -> ChoiceT m a #

some :: ChoiceT m a -> ChoiceT m [a] #

many :: ChoiceT m a -> ChoiceT m [a] #

Monad m => MonadPlus (ChoiceT m) Source # 

Methods

mzero :: ChoiceT m a #

mplus :: ChoiceT m a -> ChoiceT m a -> ChoiceT m a #

ContM m => ContM (ChoiceT m) Source # 

Methods

callWithCC :: ((a -> Label (ChoiceT m)) -> ChoiceT m a) -> ChoiceT m a Source #

AbortM m i => AbortM (ChoiceT m) i Source # 

Methods

abort :: i -> ChoiceT m a Source #

ExceptionM m j => ExceptionM (ChoiceT m) j Source # 

Methods

raise :: j -> ChoiceT m a Source #

StateM m j => StateM (ChoiceT m) j Source # 

Methods

get :: ChoiceT m j Source #

set :: j -> ChoiceT m () Source #

WriterM m j => WriterM (ChoiceT m) j Source # 

Methods

put :: j -> ChoiceT m () Source #

ReaderM m j => ReaderM (ChoiceT m) j Source # 

Methods

ask :: ChoiceT m j Source #

BaseM m n => BaseM (ChoiceT m) n Source # 

Methods

inBase :: n a -> ChoiceT m a Source #

RunM m (Maybe (a, ChoiceT m a)) r => RunM (ChoiceT m) a r Source # 

Methods

runM :: ChoiceT m a -> r Source #

data ContT i m a Source #

Add support for continuations within a prompt of type i.

Instances

MonadT (ContT i) Source # 

Methods

lift :: Monad m => m a -> ContT i m a Source #

Monad m => Monad (ContT i m) Source # 

Methods

(>>=) :: ContT i m a -> (a -> ContT i m b) -> ContT i m b #

(>>) :: ContT i m a -> ContT i m b -> ContT i m b #

return :: a -> ContT i m a #

fail :: String -> ContT i m a #

Monad m => Functor (ContT i m) Source # 

Methods

fmap :: (a -> b) -> ContT i m a -> ContT i m b #

(<$) :: a -> ContT i m b -> ContT i m a #

Monad m => Applicative (ContT i m) Source # 

Methods

pure :: a -> ContT i m a #

(<*>) :: ContT i m (a -> b) -> ContT i m a -> ContT i m b #

liftA2 :: (a -> b -> c) -> ContT i m a -> ContT i m b -> ContT i m c #

(*>) :: ContT i m a -> ContT i m b -> ContT i m b #

(<*) :: ContT i m a -> ContT i m b -> ContT i m a #

MonadPlus m => Alternative (ContT i m) Source # 

Methods

empty :: ContT i m a #

(<|>) :: ContT i m a -> ContT i m a -> ContT i m a #

some :: ContT i m a -> ContT i m [a] #

many :: ContT i m a -> ContT i m [a] #

MonadPlus m => MonadPlus (ContT i m) Source # 

Methods

mzero :: ContT i m a #

mplus :: ContT i m a -> ContT i m a -> ContT i m a #

Monad m => ContM (ContT i m) Source # 

Methods

callWithCC :: ((a -> Label (ContT i m)) -> ContT i m a) -> ContT i m a Source #

Monad m => AbortM (ContT i m) i Source # 

Methods

abort :: i -> ContT i m a Source #

(RunWriterM m j, MonadFix m) => RunWriterM (ContT i m) j Source # 

Methods

collect :: ContT i m a -> ContT i m (a, j) Source #

RunReaderM m j => RunReaderM (ContT i m) j Source # 

Methods

local :: j -> ContT i m a -> ContT i m a Source #

ExceptionM m j => ExceptionM (ContT i m) j Source # 

Methods

raise :: j -> ContT i m a Source #

StateM m j => StateM (ContT i m) j Source # 

Methods

get :: ContT i m j Source #

set :: j -> ContT i m () Source #

WriterM m j => WriterM (ContT i m) j Source # 

Methods

put :: j -> ContT i m () Source #

ReaderM m j => ReaderM (ContT i m) j Source # 

Methods

ask :: ContT i m j Source #

BaseM m n => BaseM (ContT i m) n Source # 

Methods

inBase :: n a -> ContT i m a Source #

RunM m i r => RunM (ContT i m) a ((a -> m i) -> r) Source # 

Methods

runM :: ContT i m a -> (a -> m i) -> r Source #

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 Source #

Minimal complete definition

lift

Methods

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

Promote a computation from the underlying monad.

Instances

MonadT ChoiceT Source # 

Methods

lift :: Monad m => m a -> ChoiceT m a Source #

MonadT IdT Source # 

Methods

lift :: Monad m => m a -> IdT m a Source #

MonadT (ContT i) Source # 

Methods

lift :: Monad m => m a -> ContT i m a Source #

MonadT (ExceptionT i) Source # 

Methods

lift :: Monad m => m a -> ExceptionT i m a Source #

MonadT (StateT i) Source # 

Methods

lift :: Monad m => m a -> StateT i m a Source #

Monoid i => MonadT (WriterT i) Source # 

Methods

lift :: Monad m => m a -> WriterT i m a Source #

MonadT (ReaderT i) Source # 

Methods

lift :: Monad m => m a -> ReaderT i m a Source #

class (Monad m, Monad n) => BaseM m n | m -> n where Source #

Minimal complete definition

inBase

Methods

inBase :: n a -> m a Source #

Promote a computation from the base monad.

Instances

BaseM [] [] Source # 

Methods

inBase :: [a] -> [a] Source #

BaseM Maybe Maybe Source # 

Methods

inBase :: Maybe a -> Maybe a Source #

BaseM IO IO Source # 

Methods

inBase :: IO a -> IO a Source #

BaseM Lift Lift Source # 

Methods

inBase :: Lift a -> Lift a Source #

BaseM Id Id Source # 

Methods

inBase :: Id a -> Id a Source #

BaseM m n => BaseM (ChoiceT m) n Source # 

Methods

inBase :: n a -> ChoiceT m a Source #

BaseM m n => BaseM (IdT m) n Source # 

Methods

inBase :: n a -> IdT m a Source #

BaseM (ST s) (ST s) Source # 

Methods

inBase :: ST s a -> ST s a Source #

BaseM (Cont i) (Cont i) Source # 

Methods

inBase :: Cont i a -> Cont i a Source #

BaseM (Exception i) (Exception i) Source # 

Methods

inBase :: Exception i a -> Exception i a Source #

BaseM (State i) (State i) Source # 

Methods

inBase :: State i a -> State i a Source #

Monoid i => BaseM (Writer i) (Writer i) Source # 

Methods

inBase :: Writer i a -> Writer i a Source #

BaseM (Reader i) (Reader i) Source # 

Methods

inBase :: Reader i a -> Reader i a Source #

BaseM m n => BaseM (ContT i m) n Source # 

Methods

inBase :: n a -> ContT i m a Source #

BaseM m n => BaseM (ExceptionT i m) n Source # 

Methods

inBase :: n a -> ExceptionT i m a Source #

BaseM m n => BaseM (StateT i m) n Source # 

Methods

inBase :: n a -> StateT i m a Source #

(BaseM m n, Monoid i) => BaseM (WriterT i m) n Source # 

Methods

inBase :: n a -> WriterT i m a Source #

BaseM m n => BaseM (ReaderT i m) n Source # 

Methods

inBase :: n a -> ReaderT i m a Source #

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 Source #

Classifies monads that provide access to a context of type i.

Minimal complete definition

ask

Methods

ask :: m i Source #

Get the context.

Instances

ReaderM m j => ReaderM (ChoiceT m) j Source # 

Methods

ask :: ChoiceT m j Source #

ReaderM m j => ReaderM (IdT m) j Source # 

Methods

ask :: IdT m j Source #

ReaderM (Reader i) i Source # 

Methods

ask :: Reader i i Source #

ReaderM m j => ReaderM (ContT i m) j Source # 

Methods

ask :: ContT i m j Source #

ReaderM m j => ReaderM (ExceptionT i m) j Source # 

Methods

ask :: ExceptionT i m j Source #

ReaderM m j => ReaderM (StateT i m) j Source # 

Methods

ask :: StateT i m j Source #

(ReaderM m j, Monoid i) => ReaderM (WriterT i m) j Source # 

Methods

ask :: WriterT i m j Source #

Monad m => ReaderM (ReaderT i m) i Source # 

Methods

ask :: ReaderT i m i Source #

class Monad m => WriterM m i | m -> i where Source #

Classifies monads that can collect values of type i.

Minimal complete definition

put

Methods

put :: i -> m () Source #

Add a value to the collection.

Instances

WriterM m j => WriterM (ChoiceT m) j Source # 

Methods

put :: j -> ChoiceT m () Source #

WriterM m j => WriterM (IdT m) j Source # 

Methods

put :: j -> IdT m () Source #

Monoid i => WriterM (Writer i) i Source # 

Methods

put :: i -> Writer i () Source #

WriterM m j => WriterM (ContT i m) j Source # 

Methods

put :: j -> ContT i m () Source #

WriterM m j => WriterM (ExceptionT i m) j Source # 

Methods

put :: j -> ExceptionT i m () Source #

WriterM m j => WriterM (StateT i m) j Source # 

Methods

put :: j -> StateT i m () Source #

(Monad m, Monoid i) => WriterM (WriterT i m) i Source # 

Methods

put :: i -> WriterT i m () Source #

WriterM m j => WriterM (ReaderT i m) j Source # 

Methods

put :: j -> ReaderT i m () Source #

class Monad m => StateM m i | m -> i where Source #

Classifies monads that propagate a state component of type i.

Minimal complete definition

get, set

Methods

get :: m i Source #

Get the state.

set :: i -> m () Source #

Set the state.

Instances

StateM m j => StateM (ChoiceT m) j Source # 

Methods

get :: ChoiceT m j Source #

set :: j -> ChoiceT m () Source #

StateM m j => StateM (IdT m) j Source # 

Methods

get :: IdT m j Source #

set :: j -> IdT m () Source #

StateM (State i) i Source # 

Methods

get :: State i i Source #

set :: i -> State i () Source #

StateM m j => StateM (ContT i m) j Source # 

Methods

get :: ContT i m j Source #

set :: j -> ContT i m () Source #

StateM m j => StateM (ExceptionT i m) j Source # 

Methods

get :: ExceptionT i m j Source #

set :: j -> ExceptionT i m () Source #

Monad m => StateM (StateT i m) i Source # 

Methods

get :: StateT i m i Source #

set :: i -> StateT i m () Source #

(StateM m j, Monoid i) => StateM (WriterT i m) j Source # 

Methods

get :: WriterT i m j Source #

set :: j -> WriterT i m () Source #

StateM m j => StateM (ReaderT i m) j Source # 

Methods

get :: ReaderT i m j Source #

set :: j -> ReaderT i m () Source #

class Monad m => ExceptionM m i | m -> i where Source #

Classifies monads that support raising exceptions of type i.

Minimal complete definition

raise

Methods

raise :: i -> m a Source #

Raise an exception.

Instances

ExceptionM IO SomeException Source # 

Methods

raise :: SomeException -> IO a Source #

ExceptionM m j => ExceptionM (ChoiceT m) j Source # 

Methods

raise :: j -> ChoiceT m a Source #

ExceptionM m j => ExceptionM (IdT m) j Source # 

Methods

raise :: j -> IdT m a Source #

ExceptionM (Exception i) i Source # 

Methods

raise :: i -> Exception i a Source #

ExceptionM m j => ExceptionM (ContT i m) j Source # 

Methods

raise :: j -> ContT i m a Source #

Monad m => ExceptionM (ExceptionT i m) i Source # 

Methods

raise :: i -> ExceptionT i m a Source #

ExceptionM m j => ExceptionM (StateT i m) j Source # 

Methods

raise :: j -> StateT i m a Source #

(ExceptionM m j, Monoid i) => ExceptionM (WriterT i m) j Source # 

Methods

raise :: j -> WriterT i m a Source #

ExceptionM m j => ExceptionM (ReaderT i m) j Source # 

Methods

raise :: j -> ReaderT i m a Source #

class Monad m => ContM m where Source #

Classifies monads that provide access to a computation's continuation.

Minimal complete definition

callWithCC

Methods

callWithCC :: ((a -> Label m) -> m a) -> m a Source #

Capture the current continuation.

Instances

ContM m => ContM (ChoiceT m) Source # 

Methods

callWithCC :: ((a -> Label (ChoiceT m)) -> ChoiceT m a) -> ChoiceT m a Source #

ContM m => ContM (IdT m) Source # 

Methods

callWithCC :: ((a -> Label (IdT m)) -> IdT m a) -> IdT m a Source #

ContM (Cont i) Source # 

Methods

callWithCC :: ((a -> Label (Cont i)) -> Cont i a) -> Cont i a Source #

Monad m => ContM (ContT i m) Source # 

Methods

callWithCC :: ((a -> Label (ContT i m)) -> ContT i m a) -> ContT i m a Source #

ContM m => ContM (ExceptionT i m) Source # 

Methods

callWithCC :: ((a -> Label (ExceptionT i m)) -> ExceptionT i m a) -> ExceptionT i m a Source #

ContM m => ContM (StateT i m) Source # 

Methods

callWithCC :: ((a -> Label (StateT i m)) -> StateT i m a) -> StateT i m a Source #

(ContM m, Monoid i) => ContM (WriterT i m) Source # 

Methods

callWithCC :: ((a -> Label (WriterT i m)) -> WriterT i m a) -> WriterT i m a Source #

ContM m => ContM (ReaderT i m) Source # 

Methods

callWithCC :: ((a -> Label (ReaderT i m)) -> ReaderT i m a) -> ReaderT i m a Source #

class Monad m => AbortM m i where Source #

Classifies monads that support aborting the program and returning a given final result of type i.

Minimal complete definition

abort

Methods

abort :: i -> m a Source #

Abort the program with the given value as final result.

Instances

AbortM IO ExitCode Source # 

Methods

abort :: ExitCode -> IO a Source #

AbortM m i => AbortM (ChoiceT m) i Source # 

Methods

abort :: i -> ChoiceT m a Source #

AbortM m i => AbortM (IdT m) i Source # 

Methods

abort :: i -> IdT m a Source #

Monad m => AbortM (ContT i m) i Source # 

Methods

abort :: i -> ContT i m a Source #

AbortM m i => AbortM (ExceptionT j m) i Source # 

Methods

abort :: i -> ExceptionT j m a Source #

AbortM m i => AbortM (StateT j m) i Source # 

Methods

abort :: i -> StateT j m a Source #

(AbortM m i, Monoid j) => AbortM (WriterT j m) i Source # 

Methods

abort :: i -> WriterT j m a Source #

AbortM m i => AbortM (ReaderT j m) i Source # 

Methods

abort :: i -> ReaderT j m a Source #

data Label m Source #

An explicit representation for monadic continuations.

labelCC :: ContM m => a -> m (a, a -> Label m) 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.

labelCC_ :: forall m. ContM m => m (Label m) Source #

Capture the current continuation. Later we can use jump to restart the program from this point.

jump :: Label m -> m a Source #

Restart a previously captured computation.

labelC :: (forall b. m b) -> Label m Source #

Label a given continuation.

callCC :: ContM m => ((a -> m b) -> m a) -> m a Source #

A version of callWithCC that avoids the need for an explicit use of the jump function.

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 monads and so, their run operations simply eliminate the monad.)

runId :: Id a -> a Source #

Get the result of a pure computation.

runLift :: Lift a -> a Source #

Get the result of a pure strict computation.

runIdT :: IdT m a -> m a Source #

Remove an identity layer.

runReaderT :: i -> ReaderT i m a -> m a Source #

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 i Source #

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 #

Execute a computation that may return multiple answers, collecting all possible answers.

class Monad m => RunM m a r | m a -> r where Source #

Generalized running.

Minimal complete definition

runM

Methods

runM :: m a -> r Source #

Instances

RunM Lift a a Source # 

Methods

runM :: Lift a -> a Source #

RunM Id a a Source # 

Methods

runM :: Id a -> a Source #

RunM IO a (IO a) Source # 

Methods

runM :: IO a -> IO a Source #

RunM m (Maybe (a, ChoiceT m a)) r => RunM (ChoiceT m) a r Source # 

Methods

runM :: ChoiceT m a -> r Source #

RunM m a r => RunM (IdT m) a r Source # 

Methods

runM :: IdT m a -> r Source #

RunM m (Either i a) r => RunM (ExceptionT i m) a r Source # 

Methods

runM :: ExceptionT i m a -> r Source #

(Monoid i, RunM m (a, i) r) => RunM (WriterT i m) a r Source # 

Methods

runM :: WriterT i m a -> r Source #

RunM m i r => RunM (ContT i m) a ((a -> m i) -> r) Source # 

Methods

runM :: ContT i m a -> (a -> m i) -> r Source #

RunM m (a, i) r => RunM (StateT i m) a (i -> r) Source # 

Methods

runM :: StateT i m a -> i -> r Source #

RunM m a r => RunM (ReaderT i m) a (i -> r) Source # 

Methods

runM :: ReaderT i m a -> i -> r Source #

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 Source #

Classifies monads that support changing the context for a sub-computation.

Minimal complete definition

local

Methods

local :: i -> m a -> m a Source #

Change the context for the duration of a sub-computation.

Instances

RunReaderM m j => RunReaderM (IdT m) j Source # 

Methods

local :: j -> IdT m a -> IdT m a Source #

RunReaderM (Reader i) i Source # 

Methods

local :: i -> Reader i a -> Reader i a Source #

RunReaderM m j => RunReaderM (ContT i m) j Source # 

Methods

local :: j -> ContT i m a -> ContT i m a Source #

RunReaderM m j => RunReaderM (ExceptionT i m) j Source # 

Methods

local :: j -> ExceptionT i m a -> ExceptionT i m a Source #

RunReaderM m j => RunReaderM (StateT i m) j Source # 

Methods

local :: j -> StateT i m a -> StateT i m a Source #

(RunReaderM m j, Monoid i) => RunReaderM (WriterT i m) j Source # 

Methods

local :: j -> WriterT i m a -> WriterT i m a Source #

Monad m => RunReaderM (ReaderT i m) i Source # 

Methods

local :: i -> ReaderT i m a -> ReaderT i m a Source #

class WriterM m i => RunWriterM m i | m -> i where Source #

Classifies monads that support collecting the output of a sub-computation.

Minimal complete definition

collect

Methods

collect :: m a -> m (a, i) Source #

Collect the output from a sub-computation.

Instances

RunWriterM m j => RunWriterM (IdT m) j Source # 

Methods

collect :: IdT m a -> IdT m (a, j) Source #

Monoid i => RunWriterM (Writer i) i Source # 

Methods

collect :: Writer i a -> Writer i (a, i) Source #

(RunWriterM m j, MonadFix m) => RunWriterM (ContT i m) j Source # 

Methods

collect :: ContT i m a -> ContT i m (a, j) Source #

RunWriterM m j => RunWriterM (ExceptionT i m) j Source # 

Methods

collect :: ExceptionT i m a -> ExceptionT i m (a, j) Source #

RunWriterM m j => RunWriterM (StateT i m) j Source # 

Methods

collect :: StateT i m a -> StateT i m (a, j) Source #

(Monad m, Monoid i) => RunWriterM (WriterT i m) i Source # 

Methods

collect :: WriterT i m a -> WriterT i m (a, i) Source #

RunWriterM m j => RunWriterM (ReaderT i m) j Source # 

Methods

collect :: ReaderT i m a -> ReaderT i m (a, j) Source #

class ExceptionM m i => RunExceptionM m i | m -> i where Source #

Classifies monads that support handling of exceptions.

Minimal complete definition

try

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.

Instances

RunExceptionM IO SomeException Source # 

Methods

try :: IO a -> IO (Either SomeException a) Source #

RunExceptionM m i => RunExceptionM (IdT m) i Source # 

Methods

try :: IdT m a -> IdT m (Either i a) Source #

RunExceptionM (Exception i) i Source # 

Methods

try :: Exception i a -> Exception i (Either i a) Source #

Monad m => RunExceptionM (ExceptionT i m) i Source # 

Methods

try :: ExceptionT i m a -> ExceptionT i m (Either i a) Source #

RunExceptionM m i => RunExceptionM (StateT j m) i Source # 

Methods

try :: StateT j m a -> StateT j m (Either i a) Source #

(RunExceptionM m i, Monoid j) => RunExceptionM (WriterT j m) i Source # 

Methods

try :: WriterT j m a -> WriterT j m (Either i a) Source #

RunExceptionM m i => RunExceptionM (ReaderT j m) i Source # 

Methods

try :: ReaderT j m a -> ReaderT j m (Either i a) Source #

Utility functions

asks :: ReaderM m r => (r -> a) -> m a Source #

Apply a function to the environment. Useful for accessing environmnt components.

puts :: WriterM m w => (a, w) -> m a Source #

Add content the output and return a result.

sets :: StateM m s => (s -> (a, s)) -> m a Source #

Update the state and return a result.

sets_ :: StateM m s => (s -> s) -> m () Source #

Updates the state with the given function.

raises :: ExceptionM m x => Either x a -> m a Source #

Either raise an exception or return a value. Left values signify the we should raise an exception, Right values indicate success.

mapReader :: RunReaderM m r => (r -> r) -> m a -> m a Source #

Modify the environment for the duration of a computation.

mapWriter :: RunWriterM m w => (w -> w) -> m a -> m a Source #

Modify the output of a computation.

mapException :: RunExceptionM m x => (x -> x) -> m a -> m a Source #

Modify the exception that was risen by a computation.

handle :: RunExceptionM m x => m a -> (x -> m a) -> m a Source #

Apply the given exception handler, if a computation raises an exception.

Miscellaneous

version :: (Int, Int, Int) Source #

The current version of the library.