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


-- | A simple effect system that integrates with MTL
--   
--   Please see README.md
@package simple-effects
@version 0.5.0.1

module Control.Effects1
class Monad m => MonadEffect1 eff m

-- | Use the effect described by <tt>eff</tt>.
effect1 :: (MonadEffect1 eff m, EffectCon1 eff a) => proxy eff -> EffectMsg1 eff a -> m (EffectRes1 eff a)
newtype EffHandling1 eff m
EffHandling1 :: (forall a. EffectCon1 eff a => EffectMsg1 eff a -> m (EffectRes1 eff a)) -> EffHandling1 eff m
[getHandling1] :: EffHandling1 eff m -> forall a. EffectCon1 eff a => EffectMsg1 eff a -> m (EffectRes1 eff a)

-- | The <a>EffectHandler1</a> is really just a <a>ReaderT</a> carrying
--   around the function that knows how to handle the effect.
newtype EffectHandler1 eff m a
EffectHandler1 :: ReaderT (EffHandling1 eff m) m a -> EffectHandler1 eff m a
[unpackEffectHandler1] :: EffectHandler1 eff m a -> ReaderT (EffHandling1 eff m) m a

-- | Handle the effect described by <tt>eff</tt>.
handleEffect1 :: Monad m => (forall a. EffectCon1 eff a => EffectMsg1 eff a -> m (EffectRes1 eff a)) -> EffectHandler1 eff m a -> m a
instance Control.Monad.Random.Class.MonadRandom m => Control.Monad.Random.Class.MonadRandom (Control.Effects1.EffectHandler1 eff m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Effects1.EffectHandler1 eff m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Effects1.EffectHandler1 eff m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Effects1.EffectHandler1 eff m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Effects1.EffectHandler1 eff m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Effects1.EffectHandler1 eff m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Effects1.EffectHandler1 eff m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Effects1.EffectHandler1 eff m)
instance Control.Monad.Base.MonadBase GHC.Types.IO m => Control.Monad.Base.MonadBase GHC.Types.IO (Control.Effects1.EffectHandler1 eff m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Effects1.EffectHandler1 eff)
instance Control.Monad.Reader.Class.MonadReader s m => Control.Monad.Reader.Class.MonadReader s (Control.Effects1.EffectHandler1 eff m)
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO m => Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO (Control.Effects1.EffectHandler1 eff m)
instance (Control.Effects1.MonadEffect1 eff m, Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m)) => Control.Effects1.MonadEffect1 eff (t m)
instance GHC.Base.Monad m => Control.Effects1.MonadEffect1 eff (Control.Effects1.EffectHandler1 eff m)

module Control.Effects
class Monad m => MonadEffect eff m

-- | Use the effect described by <tt>eff</tt>.
effect :: MonadEffect eff m => proxy eff -> EffectMsg eff -> m (EffectRes eff)

-- | The <a>EffectHandler</a> is really just a <a>ReaderT</a> carrying
--   around the function that knows how to handle the effect.
newtype EffectHandler eff m a
EffectHandler :: ReaderT (EffectMsg eff -> m (EffectRes eff)) m a -> EffectHandler eff m a
[unpackEffectHandler] :: EffectHandler eff m a -> ReaderT (EffectMsg eff -> m (EffectRes eff)) m a

-- | Handle the effect described by <tt>eff</tt>.
handleEffect :: Monad m => (EffectMsg eff -> m (EffectRes eff)) -> EffectHandler eff m a -> m a
instance Control.Monad.Random.Class.MonadRandom m => Control.Monad.Random.Class.MonadRandom (Control.Effects.EffectHandler eff m)
instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Effects.EffectHandler eff m)
instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Effects.EffectHandler eff m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Effects.EffectHandler eff m)
instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Effects.EffectHandler eff m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Effects.EffectHandler eff m)
instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Effects.EffectHandler eff m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Effects.EffectHandler eff m)
instance Control.Monad.Base.MonadBase GHC.Types.IO m => Control.Monad.Base.MonadBase GHC.Types.IO (Control.Effects.EffectHandler eff m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Effects.EffectHandler eff)
instance Control.Monad.Reader.Class.MonadReader s m => Control.Monad.Reader.Class.MonadReader s (Control.Effects.EffectHandler eff m)
instance Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO m => Control.Monad.Trans.Control.MonadBaseControl GHC.Types.IO (Control.Effects.EffectHandler eff m)
instance (Control.Effects.MonadEffect eff m, Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m)) => Control.Effects.MonadEffect eff (t m)
instance GHC.Base.Monad m => Control.Effects.MonadEffect eff (Control.Effects.EffectHandler eff m)

module Control.Effects.Early
data Early a

-- | Allows you to return early from a function. Make sure you
--   <a>handleEarly</a> to get the actual result out
earlyReturn :: forall a b m. MonadEffect (Early a) m => a -> m b

-- | Get the result from a computation. Either the early returned one, or
--   the regular result.
handleEarly :: Monad m => ExceptT a m a -> m a
instance GHC.Base.Monad m => Control.Effects.MonadEffect (Control.Effects.Early.Early a) (Control.Monad.Trans.Except.ExceptT a m)

module Control.Effects.List
data NonDeterministic

-- | Runs the rest of the computation for every value in the list
choose :: MonadEffect1 NonDeterministic m => [a] -> m a

-- | Signals that this branch of execution failed to produce a result.
deadEnd :: MonadEffect1 NonDeterministic m => m a

-- | Execute all the effects and collect the result in a list. Note that
--   this forces all the results, no matter which elements of the result
--   list you end up actually using. For lazyer behavior use the other
--   handlers.
evaluateToList :: Monad m => ListT m a -> m [a]

-- | Given a function, apply it to all the results.
traverseAllResults :: Monad m => (a -> m ()) -> ListT m a -> m ()

-- | Given a folding function, fold over every result. If you want to
--   terminate eary, use the <a>foldWithEarlyTermination</a> instead.
foldAllResults :: Monad m => (r -> a -> m r) -> r -> ListT m a -> m r

-- | Same as <a>foldAllResults</a> but the folding function has the ability
--   to terminate eary by returning Nothing.
foldWithEarlyTermination :: Monad m => (r -> a -> m (Maybe r)) -> r -> ListT m a -> m r

-- | Executes only the effects needed to produce the first n results.
evaluateNResults :: Monad m => Int -> ListT m a -> m [a]

-- | Executes only the effects needed to produce a single result.
evaluateOneResult :: Monad m => ListT m a -> m (Maybe a)
instance GHC.Base.Monad m => Control.Effects1.MonadEffect1 Control.Effects.List.NonDeterministic (ListT.ListT m)

module Control.Effects.Reader
data ReadEnv e
readEnv :: forall m e. MonadEffect (ReadEnv e) m => m e
handleReadEnv :: Monad m => m e -> EffectHandler (ReadEnv e) m a -> m a
handleSubreader :: MonadEffect (ReadEnv e) m => (e -> e') -> EffectHandler (ReadEnv e') m a -> m a

module Control.Effects.Signal

-- | This class allows you to "throw" a signal. For the most part signals
--   are the same as checked exceptions. The difference here is that the
--   handler has the option to provide the value that will be the result
--   _of calling the signal function_. This effectibvely allows you to have
--   recoverable exceptions at the call site, instead of just at the
--   handling site.
--   
--   This class can be considered an alias for <tt>MonadEffect (Signal a
--   b)</tt> so your code isn't required to provide any instances.
class MonadEffect (Signal a b) m => MonadEffectSignal a b m | m a -> b where signal = effect (Proxy :: Proxy (Signal a b))

-- | There are no restrictions on the type of values that can be thrown or
--   returned.
signal :: MonadEffectSignal a b m => a -> m b

-- | The handle function will return a value of this type.
data ResumeOrBreak b c

-- | Give a value to the caller of <a>signal</a> and keep going.
Resume :: b -> ResumeOrBreak b c

-- | Continue the execution after the handler. The handler will return this
--   value
Break :: c -> ResumeOrBreak b c

-- | Throw a signal with no possible recovery. The handler is forced to
--   only return the <a>Break</a> constructor because it cannot construct a
--   <a>Void</a> value.
--   
--   If this function is used along with <a>handleAsException</a>, this
--   module behaves like regular checked exceptions.
throwSignal :: Throws a m => a -> m b

-- | Handle signals of a computation. The handler function has the option
--   to provide a value to the caller of <a>signal</a> and continue
--   execution there, or do what regular exception handlers do and continue
--   execution after the handler.
handleSignal :: Monad m => (a -> m (ResumeOrBreak b c)) -> EffectHandler (Signal a b) (ExceptT c m) c -> m c

-- | This handler can only behave like a regular exception handler. If used
--   along with <a>throwSignal</a> this module behaves like regular checked
--   exceptions.
handleAsException :: Monad m => (a -> m c) -> EffectHandler (Signal a b) (ExceptT c m) c -> m c
type Throws e m = MonadEffectSignal e Void m
instance GHC.Base.Monad m => Control.Effects.Signal.MonadEffectSignal a b (Control.Effects.EffectHandler (Control.Effects.Signal.Signal a b) m)
instance (Control.Effects.Signal.MonadEffectSignal a b m, Control.Monad.Trans.Class.MonadTrans t, GHC.Base.Monad (t m)) => Control.Effects.Signal.MonadEffectSignal a b (t m)

module Control.Effects.State
data GetState s
data SetState s
type MonadEffectState s m = (MonadEffect (GetState s) m, MonadEffect (SetState s) m)
type EffectHandlerState s m = EffectHandler (GetState s) (EffectHandler (SetState s) m)
getState :: forall s m. MonadEffect (GetState s) m => m s
setState :: forall s m. MonadEffect (SetState s) m => s -> m ()
modifyState :: forall s m. MonadEffectState s m => (s -> s) -> m ()
handleGetState :: Monad m => m s -> EffectHandler (GetState s) m a -> m a
handleSetState :: Monad m => (s -> m ()) -> EffectHandler (SetState s) m a -> m a
handleState :: Monad m => m s -> (s -> m ()) -> EffectHandlerState s m a -> m a
handleStateIO :: MonadIO m => s -> EffectHandlerState s m a -> m a
handleStateT :: Monad m => s -> StateT s m a -> m a
handleSubstate :: MonadEffectState s m => Lens' s t -> t -> EffectHandlerState t m a -> m a
instance GHC.Base.Monad m => Control.Effects.MonadEffect (Control.Effects.State.GetState s) (Control.Monad.Trans.State.Lazy.StateT s m)
instance GHC.Base.Monad m => Control.Effects.MonadEffect (Control.Effects.State.SetState s) (Control.Monad.Trans.State.Lazy.StateT s m)