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


-- | Control flow data type and monad transformer.
--   
--   Control flow abstraction for short-circuiting on success and failure
--   as well as continuing with a value.
@package transformers-continue
@version 0.0.1


-- | Continue type.
module Data.Continue

-- | The <a>Continue</a> type represents values with three possibilities: a
--   value of type <tt><a>Continue</a> a b</tt> is one of
--   <tt><a>Stop</a></tt> , <tt><a>Failure</a> x</tt> or
--   <tt><a>Continue</a> a</tt>.
data Continue x a
Stop :: Continue x a
Failure :: x -> Continue x a
Continue :: a -> Continue x a
instance Data.Traversable.Traversable (Data.Continue.Continue x)
instance Data.Foldable.Foldable (Data.Continue.Continue x)
instance GHC.Base.Functor (Data.Continue.Continue x)
instance (GHC.Show.Show a, GHC.Show.Show x) => GHC.Show.Show (Data.Continue.Continue x a)
instance (GHC.Classes.Eq a, GHC.Classes.Eq x) => GHC.Classes.Eq (Data.Continue.Continue x a)
instance GHC.Base.Applicative (Data.Continue.Continue x)
instance Data.Bifunctor.Bifunctor Data.Continue.Continue
instance GHC.Base.Monad (Data.Continue.Continue x)


-- | This monad transformer extends a monad with the ability to handle
--   multiple terminating cases.
--   
--   A sequence of actions terminates normally, producing a value, only if
--   none of the actions in the sequence are <a>Stop</a> or <a>Failure</a>.
--   If one action is <a>Stop</a> or <a>Failure</a>, the rest of the
--   sequence is skipped and the composite action exits with that result.
module Control.Monad.Trans.Continue

-- | A monad transfomer that extends the <a>Continue</a> monad.
--   
--   Computations are stopes, failures or normal values.
--   
--   The <a>return</a> function returns a normal value, while
--   <tt>&gt;&gt;=</tt> exits on the first stop or failure.
newtype ContinueT x m a
ContinueT :: m (Continue x a) -> ContinueT x m a
[runContinueT] :: ContinueT x m a -> m (Continue x a)

-- | Singal a stop.
--   
--   <ul>
--   <li><pre><a>runContinueT</a> <a>stop</a> = <a>return</a>
--   <a>Stop</a></pre></li>
--   </ul>
stop :: Applicative m => ContinueT x m a

-- | Singal a failure value <tt>x</tt>.
--   
--   <ul>
--   <li><pre><a>runContinueT</a> (<a>failure</a> x) = <a>return</a>
--   (<a>Failure</a> x)</pre></li>
--   </ul>
failure :: Applicative m => x -> ContinueT x m a

-- | Singal a continue value <tt>x</tt>.
--   
--   <ul>
--   <li><pre><a>runContinueT</a> (<a>continue</a> x) = <a>return</a>
--   (<a>Continue</a> x)</pre></li>
--   </ul>
continue :: Applicative m => a -> ContinueT x m a

-- | Lift an <a>Continue</a> into an <a>ContinueT</a>
hoistContinue :: Monad m => Continue x a -> ContinueT x m a

-- | Map the unwrapped computation using the given function.
--   
--   <pre>
--   <a>runContinueT</a> (<a>mapContinueT</a> f m) = f (<a>runContinueT</a> m)
--   </pre>
mapContinueT :: (m (Continue x a) -> n (Continue y b)) -> ContinueT x m a -> ContinueT y n b

-- | Map over both failure and continue.
bimapContinueT :: Functor m => (x -> y) -> (a -> b) -> ContinueT x m a -> ContinueT y m b

-- | Map over failure.
firstContinueT :: Functor m => (x -> y) -> ContinueT x m a -> ContinueT y m a

-- | Map over continue.
secondContinueT :: Functor m => (a -> b) -> ContinueT x m a -> ContinueT x m b

-- | Map over failure.
mapFailure :: Functor m => (x -> y) -> ContinueT x m a -> ContinueT y m a

-- | Lift an <a>Maybe</a> into an <a>ContinueT</a>
--   
--   <ul>
--   <li><pre><a>runContinueT</a> (<a>stopFromNothing</a> <a>Nothing</a>) =
--   <a>return</a> <a>Stop</a></pre></li>
--   <li><pre><a>runContinueT</a> (<a>stopFromNothing</a> (<a>Just</a> a))
--   = <a>return</a> (<a>Continue</a> a)</pre></li>
--   </ul>
stopFromNothing :: Applicative m => Maybe a -> ContinueT x m a

-- | Lift an <a>Either</a> into an <a>ContinueT</a>
--   
--   <ul>
--   <li><pre><a>runContinueT</a> (<a>hoistEither</a> (<a>Left</a> x)) =
--   <a>return</a> (<a>Failure</a> x)</pre></li>
--   <li><pre><a>runContinueT</a> (<a>hoistEither</a> (<a>Right</a> a)) =
--   <a>return</a> (<a>Continue</a> a)</pre></li>
--   </ul>
hoistEither :: Applicative m => Either x a -> ContinueT x m a

-- | Utility function for EitherT pattern synonym over <a>ExceptT</a>
liftEitherT :: Monad m => ExceptT x m a -> ContinueT x m a

-- | Convert an <a>ExceptT</a> into an <a>ContinueT</a>
--   
--   <ul>
--   <li><pre><tt>runExceptT</tt> (<a>return</a> (<a>Left</a> x)) =
--   <a>failure</a> x</pre></li>
--   <li><pre><tt>runExceptT</tt> (<a>return</a> (<a>Right</a> a)) =
--   <a>continue</a> a</pre></li>
--   </ul>
liftExceptT :: Monad m => ExceptT x m a -> ContinueT x m a

-- | Utility function for EitherT pattern synonym over <a>ExceptT</a>
runToEitherT :: Monad m => ContinueT x m () -> ExceptT x m ()

-- | Convert an <a>ContinueT</a> into an <a>ExceptT</a>
--   
--   <ul>
--   <li><pre><tt>runExceptT</tt> (<a>runToExceptT</a> (<a>continue</a> a))
--   = <a>return</a> (<a>Right</a> a)</pre></li>
--   <li><pre><tt>runExceptT</tt> (<a>runToExceptT</a> (<a>failure</a> x))
--   = <a>return</a> (<a>Left</a> x)</pre></li>
--   <li><pre><tt>runExceptT</tt> (<a>runToExceptT</a> <a>stop</a>) =
--   <a>return</a> (<a>Right</a> ())</pre></li>
--   </ul>
runToExceptT :: Monad m => ContinueT x m () -> ExceptT x m ()
instance Data.Traversable.Traversable m => Data.Traversable.Traversable (Control.Monad.Trans.Continue.ContinueT x m)
instance Data.Foldable.Foldable m => Data.Foldable.Foldable (Control.Monad.Trans.Continue.ContinueT x m)
instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Continue.ContinueT x m)
instance (GHC.Base.Applicative m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.Continue.ContinueT x m)
instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Continue.ContinueT x m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Continue.ContinueT x m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Continue.ContinueT x)