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


-- | An approach to managing composable effects, ala mtl/transformers/extensible-effects/Eff
--   
--   An approach to managing composable effects, ala
--   mtl<i>transformers</i>extensible-effects/Eff
@package transformers-eff
@version 0.2.0.0

module Control.Effect

-- | The <a>Eff</a> monad transformer is used to write programs that
--   require access to specific effects. In this library, effects are
--   combined by stacking multiple <a>Eff</a>s together, just as you would
--   do with traditional monad transformers. <a>Eff</a>s are parameterized
--   by an effect <i>algebra</i>. This is a description of programs in a
--   single effect, such as non-determinism (<tt>[]</tt>)or exceptions
--   (<tt>Either e</tt>). As <a>Eff</a> is a monad transformer, <tt>m</tt>
--   is the monad that <a>Eff</a> transforms, which can itself be another
--   instance of <a>Eff</a>.
newtype Eff f m a
Eff :: (forall g r. (forall x. Sum f m x -> Cont (g r) x) -> Cont (g r) a) -> Eff f m a

-- | In order to run <a>Eff</a> computations, we need to provide a way to
--   run its effects in a specific monad transformer. Notice that
--   <tt>run</tt> eliminates one layer of <a>Eff</a>, returning you with
--   the original <tt>a</tt> now captured under the result of the effects
--   described by the <tt>effect</tt> functor.
translate :: (Monad m, Monad (t m), MonadTrans t) => (forall x r. f x -> ContT r (t m) x) -> Eff f m a -> t m a

-- | <tt>LiftProgram</tt> defines an <tt>mtl</tt>-style type class for
--   automatically lifting effects into <a>Eff</a> stacks. When exporting
--   libraries that you intend to publish on Hackage, it's suggested that
--   you still provide your own type class (such as <tt>MonadThrow</tt> or
--   <tt>MonadHTTP</tt>) to avoid locking people into this library, but
--   <a>interpret</a> can be useful to define your own instances of that
--   type class for <a>Eff</a>.
class (IsEff m, Monad m) => Interprets p m | m -> p
interpret :: Interprets p m => p a -> m a
interpret :: Interprets p m => p a -> m a

-- | The <a>IsEff</a> type family is used to make sure that a given monad
--   stack is based around <a>Eff</a>. This is important, as it allows us
--   to reason about Eff-based type classes, knowing that <i>only</i>
--   <a>Eff</a> implements them, thus giving us the orthogonal-handling
--   properties that we desire.
instance GHC.Base.Monad m => Control.Effect.Interprets f (Control.Effect.Eff f m)
instance (GHC.Base.Monad m, Control.Effect.Interprets f (Control.Effect.Eff h m)) => Control.Effect.Interprets f (Control.Effect.Eff g (Control.Effect.Eff h m))
instance GHC.Base.Functor (Control.Effect.Eff f m)
instance GHC.Base.Applicative (Control.Effect.Eff f m)
instance GHC.Base.Monad (Control.Effect.Eff f m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Effect.Eff f)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Effect.Eff effect m)
instance GHC.Base.Functor (Control.Effect.Cont r)
instance GHC.Base.Applicative (Control.Effect.Cont r)
instance GHC.Base.Monad (Control.Effect.Cont r)

module Control.Effect.Environment
class (Monad m) => EffEnvironment env m | m -> env
liftReader :: EffEnvironment env m => Reader env a -> m a
runInEnvironment :: Monad m => Eff (Reader env) m a -> env -> m a
ask :: (EffEnvironment env m) => m env
asks :: (EffEnvironment a m) => (a -> b) -> m b
mapEnvironment :: (EffEnvironment env m) => (env -> env') -> Eff (Reader env') m a -> m a
liftReader :: EffEnvironment env m => Reader env a -> m a
effToReaderT :: Monad m => Eff (Reader e) m a -> ReaderT e m a
readerTToEff :: (Monad m, EffEnvironment e m) => ReaderT e m a -> m a
instance GHC.Base.Monad m => Control.Effect.Environment.EffEnvironment env (Control.Effect.Eff (Control.Monad.Trans.Reader.Reader env) m)
instance Control.Effect.Environment.EffEnvironment env m => Control.Effect.Environment.EffEnvironment env (Control.Effect.Eff effects m)

module Control.Effect.Exception
class Monad m => EffException e m | m -> e
liftEither :: EffException e m => Either e a -> m a
try :: Monad m => Eff (Either e) m a -> m (Either e a)
throw :: EffException e m => e -> m a
liftEither :: EffException e m => Either e a -> m a
effToExceptT :: Monad m => Eff (Either e) m a -> ExceptT e m a
exceptTToEff :: (Monad m, EffException e m) => ExceptT e m a -> m a
instance GHC.Base.Monad m => Control.Effect.Exception.EffException e (Control.Effect.Eff (Data.Either.Either e) m)
instance Control.Effect.Exception.EffException e m => Control.Effect.Exception.EffException e (Control.Effect.Eff f m)

module Control.Effect.IO
data UIO a
runUIO :: UIO a -> IO a

-- | Lift an <a>IO</a> action and explictly throw an synchronous IO
--   exceptions that occur.
syncIO :: (Interprets (Either SomeException) m, EffUIO m) => IO a -> m a
class Monad m => EffUIO m
liftUIO :: EffUIO m => UIO a -> m a
runExceptionalIO :: Eff (Either SomeException) IO a -> IO a
instance GHC.Base.Monad Control.Effect.IO.UIO
instance GHC.Base.Applicative Control.Effect.IO.UIO
instance GHC.Base.Functor Control.Effect.IO.UIO
instance Control.Effect.IO.EffUIO GHC.Types.IO
instance Control.Effect.IO.EffUIO Control.Effect.IO.UIO
instance Control.Effect.IO.EffUIO m => Control.Effect.IO.EffUIO (Control.Effect.Eff r m)

module Control.Effect.Identity
runIdentity :: Monad m => Eff Identity m a -> m a

module Control.Effect.Nondeterminism
class Monad m => Nondeterministic m
liftNondeterminism :: Nondeterministic m => [a] -> m a
choose :: (Nondeterministic m, Foldable f) => f a -> m a
runNondeterminism :: (Monad m, Foldable f) => (b -> a -> b) -> b -> Eff f m a -> m b
runNondeterminismM :: (Monad m, Foldable f) => (b -> a -> m b) -> m b -> Eff f m a -> m b
mzero :: Nondeterministic m => m a
mplus :: Nondeterministic m => m a -> m a -> m a
instance GHC.Base.Monad m => Control.Effect.Nondeterminism.Nondeterministic (Control.Effect.Eff [] m)
instance Control.Effect.Nondeterminism.Nondeterministic m => Control.Effect.Nondeterminism.Nondeterministic (Control.Effect.Eff f m)

module Control.Effect.State
runState :: Monad m => Eff (State s) m a -> s -> m (a, s)
evalState :: Monad m => Eff (State s) m a -> s -> m a
execState :: Monad m => Eff (State s) m a -> s -> m s
get :: (Interprets (State state) m) => m state
put :: (Interprets (State state) m) => state -> m ()
modify :: (Interprets (State state) m) => (state -> state) -> m ()
modify' :: (Interprets (State state) m) => (state -> state) -> m ()
gets :: (Interprets (State state) m) => (state -> a) -> m a