-- 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.2.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 rally 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 rally 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.State
data GetState s
data SetState s
getState :: forall m s. MonadEffect (GetState s) m => m s
setState :: forall m s. MonadEffect (SetState s) m => s -> m ()
modifyState :: forall m s. (MonadEffect (GetState s) m, MonadEffect (SetState 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
handleStateIO :: MonadIO m => s -> EffectHandler (GetState s) (EffectHandler (SetState s) m) a -> m a
handleState :: Monad m => s -> EffectHandler (GetState s) (EffectHandler (SetState s) (StateT s m)) a -> m a
handleSubstate :: forall s t m a. (MonadEffect (GetState s) m, MonadEffect (SetState s) m) => Lens' s t -> t -> EffectHandler (GetState t) (EffectHandler (SetState t) m) a -> m a
type MonadEffectState s m = (MonadEffect (GetState s) m, MonadEffect (SetState s) 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.List
data List

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

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

-- | A generic handler for the List effect. Takes a handler for the ListT
--   transformer as a param.
handleList :: Monad m => (ListT m a -> m b) -> EffectHandler1 List (ListT m) a -> m b

-- | 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 => EffectHandler1 List (ListT m) a -> m [a]

-- | Given a function, apply it to all the results.
traverseAllResults :: Monad m => (a -> m ()) -> EffectHandler1 List (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 -> EffectHandler1 List (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 -> EffectHandler1 List (ListT m) a -> m r

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

-- | Executes only the effects needed to produce a single result.
evaluateOneResult :: Monad m => EffectHandler1 List (ListT m) a -> m (Maybe a)
test :: IO (Maybe Int)