-- 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.0.0


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

-- | Add support for propagating a context.
data ReaderT i m a

-- | Add support for collecting values.
data WriterT i m a

-- | Add support for threading state.
data StateT i m a

-- | Add support for exceptions.
data ExceptionT i m a

-- | Add support for jumps.
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

-- | 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 go back to the continuation 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

-- | 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 :: 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

-- | 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 separate state threads.
class (StateM m i) => RunStateM m i | m -> i
runS :: (RunStateM m i) => 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)

-- | The current version of the library.
version :: (Int, Int, Int)
instance (Monad m) => RunExceptionM (ExceptionT 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 (RunStateM m j) => RunStateM (ExceptionT i m) j
instance (Monad m) => RunStateM (StateT i m) i
instance (RunStateM m j, Monoid i) => RunStateM (WriterT i m) j
instance (RunStateM m j) => RunStateM (ReaderT i m) j
instance (RunWriterM m j) => RunWriterM (ExceptionT i m) j
instance (RunWriterM m j) => RunWriterM (StateT i m) j
instance (Monad m, Monoid i) => RunWriterM (WriterT i m) i
instance (RunWriterM m j) => RunWriterM (ReaderT 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 (Monad m) => RunReaderM (ReaderT i m) i
instance (Monad m) => ContM (ContT i 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 (ExceptionM m j) => ExceptionM (ContT i 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 (Monad m) => ExceptionM (ExceptionT i m) i
instance (StateM m j) => StateM (ContT i 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 (Monad m) => StateM (StateT i m) i
instance (WriterM m j) => WriterM (ContT i 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 (Monad m, Monoid i) => WriterM (WriterT i m) i
instance (ReaderM m j) => ReaderM (ContT i 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 (Monad m) => ReaderM (ReaderT i m) i
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 (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 Id
instance (Monad m) => Functor (ContT i 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 Functor Id
instance (Monad m) => Monad (ContT i 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 Id
instance (BaseM m n) => BaseM (ContT i 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 Id Id
instance BaseM [] []
instance BaseM Maybe Maybe
instance BaseM IO IO
instance MonadT (ContT i)
instance MonadT (ExceptionT i)
instance (Monoid i) => MonadT (WriterT i)
instance MonadT (StateT i)
instance MonadT (ReaderT i)


-- | 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 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 RunStateM (State 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)