-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A collection of monad transformers.
--   
--   A collection of monad transformers.
@package monadLib
@version 3.6.2


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

-- | Computations with no effects.
data Id a

-- | Computation with no effects (strict).
data Lift a

-- | Adds no new features. Useful as a placeholder.
data IdT m a

-- | Add support for propagating a context of type <tt>i</tt>.
data ReaderT i m a

-- | Add support for collecting values of type <tt>i</tt>. The type
--   <tt>i</tt> 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.
data WriterT i m a

-- | Add support for threading state of type <tt>i</tt>.
data StateT i m a

-- | Add support for exceptions of type <tt>i</tt>.
data ExceptionT i m a

-- | Add support for multiple answers.
data ChoiceT m a

-- | Add support for continuations within a prompt of type <tt>i</tt>.
data ContT i m a
class MonadT t
lift :: (MonadT t, Monad m) => m a -> t m a
class (Monad m, Monad n) => BaseM m n | m -> n
inBase :: BaseM m n => n a -> m a

-- | Classifies monads that provide access to a context of type <tt>i</tt>.
class Monad m => ReaderM m i | m -> i
ask :: ReaderM m i => m i

-- | Classifies monads that can collect values of type <tt>i</tt>.
class Monad m => WriterM m i | m -> i
put :: WriterM m i => i -> m ()

-- | Classifies monads that propagate a state component of type <tt>i</tt>.
class Monad m => StateM m i | m -> i
get :: StateM m i => m i
set :: StateM m i => i -> m ()

-- | Classifies monads that support raising exceptions of type <tt>i</tt>.
class Monad m => ExceptionM m i | m -> i
raise :: ExceptionM m i => i -> m a

-- | Classifies monads that provide access to a computation's continuation.
class Monad m => ContM m
callCC :: ContM m => ((a -> m b) -> m a) -> m a

-- | Classifies monads that support aborting the program and returning a
--   given final result of type <tt>i</tt>.
class Monad m => AbortM m i
abort :: AbortM m i => i -> m a

-- | An explicit representation for continuations that store a value.
data Label m a

-- | Capture the current continuation. This function is like <a>return</a>,
--   except that it also captures the current continuation. Later, we can
--   use <a>jump</a> to repeat the computation from this point onwards but
--   with a possibly different value.
labelCC :: ContM m => a -> m (a, Label m a)

-- | Change the value passed to a previously captured continuation.
jump :: ContM m => a -> Label m a -> m b

-- | Get the result of a pure computation.
runId :: Id a -> a

-- | Get the result of a pure strict computation.
runLift :: Lift a -> a

-- | Remove an identity layer.
runIdT :: IdT m a -> m a

-- | Execute a reader computation in the given context.
runReaderT :: i -> ReaderT i m a -> m a

-- | Execute a writer computation. Returns the result and the collected
--   output.
runWriterT :: Monad m => WriterT 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.
runStateT :: i -> StateT i m a -> m (a, i)

-- | Execute a computation with exceptions. Successful results are tagged
--   with <a>Right</a>, exceptional results are tagged with <a>Left</a>.
runExceptionT :: ExceptionT i m a -> m (Either i a)

-- | Execute a computation with the given continuation.
runContT :: (a -> m i) -> ContT i m a -> m i

-- | Execute a computation that may return multiple answers. The resulting
--   computation returns <a>Nothing</a> if no answers were found, or
--   <tt>Just (answer,new_comp)</tt>, where <tt>answer</tt> is an answer,
--   and <tt>new_comp</tt> is a computation that may produce more answers.
--   The search is depth-first and left-biased with respect to the
--   <a>mplus</a> operation.
runChoiceT :: Monad m => ChoiceT m a -> m (Maybe (a, ChoiceT m a))

-- | Execute a computation that may return multiple answers, returning at
--   most one answer.
findOne :: Monad m => ChoiceT m a -> m (Maybe a)

-- | Execute a computation that may return multiple answers, collecting all
--   possible answers.
findAll :: Monad m => ChoiceT m a -> m [a]

-- | Generalized running.
class Monad m => RunM m a r | m a -> r
runM :: RunM m a r => m a -> r

-- | Classifies monads that support changing the context for a
--   sub-computation.
class ReaderM m i => RunReaderM m i | m -> i
local :: RunReaderM m i => i -> m a -> m a

-- | Classifies monads that support collecting the output of a
--   sub-computation.
class WriterM m i => RunWriterM m i | m -> i
collect :: RunWriterM m i => m a -> m (a, i)

-- | Classifies monads that support handling of exceptions.
class ExceptionM m i => RunExceptionM m i | m -> i
try :: RunExceptionM m i => m a -> m (Either i a)

-- | Apply a function to the environment. Useful for accessing environmnt
--   components.
asks :: ReaderM m r => (r -> a) -> m a

-- | Add content the output and return a result.
puts :: WriterM m w => (a, w) -> m a

-- | Update the state and return a result.
sets :: StateM m s => (s -> (a, s)) -> m a

-- | Updates the state with the given function.
sets_ :: StateM m s => (s -> s) -> m ()

-- | Either raise an exception or return a value. <a>Left</a> values
--   signify the we should raise an exception, <a>Right</a> values indicate
--   success.
raises :: ExceptionM m x => Either x a -> m a

-- | Modify the environment for the duration of a computation.
mapReader :: RunReaderM m r => (r -> r) -> m a -> m a

-- | Modify the output of a computation.
mapWriter :: RunWriterM m w => (w -> w) -> m a -> m a

-- | Modify the exception that was risen by a computation.
mapException :: RunExceptionM m x => (x -> x) -> m a -> m a

-- | Apply the given exception handler, if a computation raises an
--   exception.
handle :: RunExceptionM m x => m a -> (x -> m a) -> m a

-- | The current version of the library.
version :: (Int, Int, Int)
instance AbortM m i => AbortM (ChoiceT m) i
instance AbortM m i => AbortM (ExceptionT j m) i
instance AbortM m i => AbortM (StateT j m) i
instance (AbortM m i, Monoid j) => AbortM (WriterT j m) i
instance AbortM m i => AbortM (ReaderT j m) i
instance AbortM m i => AbortM (IdT m) i
instance AbortM IO ExitCode
instance Monad m => AbortM (ContT i m) i
instance RunExceptionM m i => RunExceptionM (StateT j m) i
instance (RunExceptionM m i, Monoid j) => RunExceptionM (WriterT j m) i
instance RunExceptionM m i => RunExceptionM (ReaderT j m) i
instance RunExceptionM m i => RunExceptionM (IdT m) i
instance Monad m => RunExceptionM (ExceptionT i m) i
instance RunExceptionM IO SomeException
instance (RunWriterM m j, MonadFix m) => RunWriterM (ContT i m) j
instance RunWriterM m j => RunWriterM (ExceptionT i m) j
instance RunWriterM m j => RunWriterM (StateT i m) j
instance RunWriterM m j => RunWriterM (ReaderT i m) j
instance RunWriterM m j => RunWriterM (IdT m) j
instance (Monad m, Monoid i) => RunWriterM (WriterT i m) i
instance RunReaderM m j => RunReaderM (ContT i m) j
instance RunReaderM m j => RunReaderM (ExceptionT i m) j
instance RunReaderM m j => RunReaderM (StateT i m) j
instance (RunReaderM m j, Monoid i) => RunReaderM (WriterT i m) j
instance RunReaderM m j => RunReaderM (IdT m) j
instance Monad m => RunReaderM (ReaderT i m) i
instance Monad m => ContM (ContT i m)
instance ContM m => ContM (ChoiceT m)
instance ContM m => ContM (ExceptionT i m)
instance (ContM m, Monoid i) => ContM (WriterT i m)
instance ContM m => ContM (StateT i m)
instance ContM m => ContM (ReaderT i m)
instance ContM m => ContM (IdT m)
instance ExceptionM m j => ExceptionM (ContT i m) j
instance ExceptionM m j => ExceptionM (ChoiceT m) j
instance ExceptionM m j => ExceptionM (StateT i m) j
instance (ExceptionM m j, Monoid i) => ExceptionM (WriterT i m) j
instance ExceptionM m j => ExceptionM (ReaderT i m) j
instance ExceptionM m j => ExceptionM (IdT m) j
instance Monad m => ExceptionM (ExceptionT i m) i
instance ExceptionM IO SomeException
instance StateM m j => StateM (ContT i m) j
instance StateM m j => StateM (ChoiceT m) j
instance StateM m j => StateM (ExceptionT i m) j
instance (StateM m j, Monoid i) => StateM (WriterT i m) j
instance StateM m j => StateM (ReaderT i m) j
instance StateM m j => StateM (IdT m) j
instance Monad m => StateM (StateT i m) i
instance WriterM m j => WriterM (ContT i m) j
instance WriterM m j => WriterM (ChoiceT m) j
instance WriterM m j => WriterM (ExceptionT i m) j
instance WriterM m j => WriterM (StateT i m) j
instance WriterM m j => WriterM (ReaderT i m) j
instance WriterM m j => WriterM (IdT m) j
instance (Monad m, Monoid i) => WriterM (WriterT i m) i
instance ReaderM m j => ReaderM (ContT i m) j
instance ReaderM m j => ReaderM (ChoiceT m) j
instance ReaderM m j => ReaderM (ExceptionT i m) j
instance ReaderM m j => ReaderM (StateT i m) j
instance (ReaderM m j, Monoid i) => ReaderM (WriterT i m) j
instance ReaderM m j => ReaderM (IdT m) j
instance Monad m => ReaderM (ReaderT i m) i
instance MonadPlus m => MonadPlus (ContT i m)
instance Monad m => MonadPlus (ChoiceT m)
instance MonadPlus m => MonadPlus (ExceptionT i m)
instance (MonadPlus m, Monoid i) => MonadPlus (WriterT i m)
instance MonadPlus m => MonadPlus (StateT i m)
instance MonadPlus m => MonadPlus (ReaderT i m)
instance MonadPlus m => MonadPlus (IdT m)
instance MonadFix m => MonadFix (ExceptionT i m)
instance (MonadFix m, Monoid i) => MonadFix (WriterT i m)
instance MonadFix m => MonadFix (StateT i m)
instance MonadFix m => MonadFix (ReaderT i m)
instance MonadFix m => MonadFix (IdT m)
instance MonadFix Lift
instance MonadFix Id
instance MonadPlus m => Alternative (ContT i m)
instance Monad m => Alternative (ChoiceT m)
instance MonadPlus m => Alternative (ExceptionT i m)
instance (MonadPlus m, Monoid i) => Alternative (WriterT i m)
instance MonadPlus m => Alternative (StateT i m)
instance MonadPlus m => Alternative (ReaderT i m)
instance MonadPlus m => Alternative (IdT m)
instance Monad m => Applicative (ContT i m)
instance Monad m => Applicative (ChoiceT m)
instance Monad m => Applicative (ExceptionT i m)
instance (Monad m, Monoid i) => Applicative (WriterT i m)
instance Monad m => Applicative (StateT i m)
instance Monad m => Applicative (ReaderT i m)
instance Monad m => Applicative (IdT m)
instance Applicative Lift
instance Applicative Id
instance Monad m => Functor (ContT i m)
instance Monad m => Functor (ChoiceT m)
instance Monad m => Functor (ExceptionT i m)
instance (Monad m, Monoid i) => Functor (WriterT i m)
instance Monad m => Functor (StateT i m)
instance Monad m => Functor (ReaderT i m)
instance Monad m => Functor (IdT m)
instance Functor Lift
instance Functor Id
instance Monad m => Monad (ContT i m)
instance Monad m => Monad (ChoiceT m)
instance Monad m => Monad (ExceptionT i m)
instance (Monad m, Monoid i) => Monad (WriterT i m)
instance Monad m => Monad (StateT i m)
instance Monad m => Monad (ReaderT i m)
instance Monad m => Monad (IdT m)
instance Monad Lift
instance Monad Id
instance BaseM m n => BaseM (ContT i m) n
instance BaseM m n => BaseM (ChoiceT m) n
instance BaseM m n => BaseM (ExceptionT i m) n
instance (BaseM m n, Monoid i) => BaseM (WriterT i m) n
instance BaseM m n => BaseM (StateT i m) n
instance BaseM m n => BaseM (ReaderT i m) n
instance BaseM m n => BaseM (IdT m) n
instance BaseM (ST s) (ST s)
instance BaseM Lift Lift
instance BaseM Id Id
instance BaseM [] []
instance BaseM Maybe Maybe
instance BaseM IO IO
instance MonadT (ContT i)
instance MonadT ChoiceT
instance MonadT (ExceptionT i)
instance Monoid i => MonadT (WriterT i)
instance MonadT (StateT i)
instance MonadT (ReaderT i)
instance MonadT IdT
instance RunM m (Maybe (a, ChoiceT m a)) r => RunM (ChoiceT m) a r
instance RunM m i r => RunM (ContT i m) a ((a -> m i) -> r)
instance RunM m (Either i a) r => RunM (ExceptionT i m) a r
instance RunM m (a, i) r => RunM (StateT i m) a (i -> r)
instance (Monoid i, RunM m (a, i) r) => RunM (WriterT i m) a r
instance RunM m a r => RunM (ReaderT i m) a (i -> r)
instance RunM m a r => RunM (IdT m) a r
instance RunM IO a (IO a)
instance RunM Lift a a
instance RunM Id a a


-- | This module defines a number of functions that make it easy to get the
--   functionality of MonadLib for user-defined newtypes.
module MonadLib.Derive

-- | An isomorphism between (usually) monads. Typically the constructor and
--   selector of a newtype delcaration.
data Iso m n
Iso :: (forall a. m a -> n a) -> (forall a. n a -> m a) -> Iso m n

-- | Derive the implementation of <a>fmap</a> from <a>Functor</a>.
derive_fmap :: Functor m => Iso m n -> (a -> b) -> n a -> n b

-- | Derive the implementation of <a>return</a> from <a>Monad</a>.
derive_return :: Monad m => Iso m n -> (a -> n a)

-- | Derive the implementation of <a>&gt;&gt;=</a> from <a>Monad</a>.
derive_bind :: Monad m => Iso m n -> n a -> (a -> n b) -> n b
derive_fail :: Monad m => Iso m n -> String -> n a

-- | Derive the implementation of <a>mfix</a> from <a>MonadFix</a>.
derive_mfix :: MonadFix m => Iso m n -> (a -> n a) -> n a

-- | Derive the implementation of <a>ask</a> from <a>ReaderM</a>.
derive_ask :: ReaderM m i => Iso m n -> n i

-- | Derive the implementation of <a>put</a> from <a>WriterM</a>.
derive_put :: WriterM m i => Iso m n -> i -> n ()

-- | Derive the implementation of <a>get</a> from <a>StateM</a>.
derive_get :: StateM m i => Iso m n -> n i

-- | Derive the implementation of <a>set</a> from <a>StateM</a>.
derive_set :: StateM m i => Iso m n -> i -> n ()

-- | Derive the implementation of <a>raise</a> from <a>ExceptionM</a>.
derive_raise :: ExceptionM m i => Iso m n -> i -> n a

-- | Derive the implementation of <a>callCC</a> from <a>ContM</a>.
derive_callCC :: ContM m => Iso m n -> ((a -> n b) -> n a) -> n a
derive_abort :: AbortM m i => Iso m n -> i -> n a

-- | Derive the implementation of <a>local</a> from <a>RunReaderM</a>.
derive_local :: RunReaderM m i => Iso m n -> i -> n a -> n a

-- | Derive the implementation of <a>collect</a> from <a>RunWriterM</a>.
derive_collect :: RunWriterM m i => Iso m n -> n a -> n (a, i)

-- | Derive the implementation of <a>try</a> from <a>RunExceptionM</a>.
derive_try :: RunExceptionM m i => Iso m n -> n a -> n (Either i a)

-- | Derive the implementation of <a>mzero</a> from <a>MonadPlus</a>.
derive_mzero :: MonadPlus m => Iso m n -> n a

-- | Derive the implementation of <a>mplus</a> from <a>MonadPlus</a>.
derive_mplus :: MonadPlus m => Iso m n -> n a -> n a -> n a

-- | Derive the implementation of <a>lift</a> from <a>MonadT</a>.
derive_lift :: (MonadT t, Monad m) => Iso (t m) n -> m a -> n a

-- | Derive the implementation of <a>inBase</a> from <a>BaseM</a>.
derive_inBase :: BaseM m x => Iso m n -> x a -> n a

-- | Derive the implementation of the <a>runM</a> function from
--   <a>RunM</a>.
derive_runM :: RunM m a r => Iso m n -> n a -> r


-- | This module contains a collection of monads that are defined in terms
--   of the monad transformers from <a>MonadLib</a>. The definitions in
--   this module are completely mechanical and so this module may become
--   obsolete if support for automated derivations for instances becomes
--   well supported across implementations.
module MonadLib.Monads
data Reader i a
data Writer i a
data State i a
data Exception i a
data Cont i a
runReader :: i -> Reader i a -> a
runWriter :: Writer i a -> (a, i)
runState :: i -> State i a -> (a, i)
runException :: Exception i a -> Either i a
runCont :: (a -> i) -> Cont i a -> i
instance RunExceptionM (Exception i) i
instance Monoid i => RunWriterM (Writer i) i
instance RunReaderM (Reader i) i
instance ContM (Cont i)
instance ExceptionM (Exception i) i
instance StateM (State i) i
instance Monoid i => WriterM (Writer i) i
instance ReaderM (Reader i) i
instance MonadFix (Exception i)
instance MonadFix (State i)
instance Monoid i => MonadFix (Writer i)
instance MonadFix (Reader i)
instance Functor (Cont i)
instance Functor (Exception i)
instance Functor (State i)
instance Monoid i => Functor (Writer i)
instance Functor (Reader i)
instance Monad (Cont i)
instance Monad (Exception i)
instance Monad (State i)
instance Monoid i => Monad (Writer i)
instance Monad (Reader i)
instance BaseM (Cont i) (Cont i)
instance BaseM (Exception i) (Exception i)
instance BaseM (State i) (State i)
instance Monoid i => BaseM (Writer i) (Writer i)
instance BaseM (Reader i) (Reader i)