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

-- | Simple monad transformer for imperative-style loops
--   
--   A library of looping constructs with continue and
--   exit control flow statements.
@package control-monad-loop
@version 0.1

module Control.Monad.Trans.Loop

-- | LoopT is a monad transformer for the loop body. It provides two
--   capabilities:
--   
--   
--   
- continue to the next iteration.
--   
- exit the whole loop.
--   
newtype LoopT c e (m :: Type -> Type) a
LoopT :: (forall r. () => (c -> m r) -> (e -> m r) -> (a -> m r) -> m r) -> LoopT c e (m :: Type -> Type) a
[runLoopT] :: LoopT c e (m :: Type -> Type) a -> forall r. () => (c -> m r) -> (e -> m r) -> (a -> m r) -> m r

-- | Call a loop body, passing it a continuation for the next iteration.
--   This can be used to construct custom looping constructs. For example,
--   here is the definition of foreach:
--   
--   
--   foreach list body = loop list
--     where loop []     = return ()
--           loop (x:xs) = stepLoopT (body x) (\_ -> loop xs)
--   
stepLoopT :: Monad m => LoopT c e m c -> (c -> m e) -> m e

-- | Skip the rest of the loop body and go to the next iteration.
continue :: forall e (m :: Type -> Type) a. LoopT () e m a

-- | Break out of the loop entirely.
exit :: forall c (m :: Type -> Type) a. LoopT c () m a

-- | Like continue, but return a value from the loop body.
continueWith :: forall c e (m :: Type -> Type) a. c -> LoopT c e m a

-- | Like exit, but return a value from the loop as a whole. See the
--   documentation of iterateLoopT for an example.
exitWith :: forall e c (m :: Type -> Type) a. e -> LoopT c e m a

-- | Call the loop body with each item in the list.
--   
--   If you do not need to continue or exit the loop,
--   consider using forM_ instead.
foreach :: Monad m => [a] -> (a -> LoopT c () m c) -> m ()

-- | Repeat the loop body while the predicate holds. Like a while
--   loop in C, the condition is tested first.
while :: Monad m => m Bool -> LoopT c () m c -> m ()

-- | Like a do while loop in C, where the condition is tested
--   after the loop body.
--   
--   doWhile returns the result of the last iteration. This is
--   possible because, unlike foreach and while, the loop
--   body is guaranteed to be executed at least once.
doWhile :: Monad m => LoopT a a m a -> m Bool -> m a

-- | Execute the loop body once. This is a convenient way to introduce
--   early exit support to a block of code.
--   
--   continue and exit do the same thing inside of
--   once.
once :: Monad m => LoopT a a m a -> m a

-- | Execute the loop body again and again. The only way to exit
--   repeatLoopT is to call exit or exitWith.
repeatLoopT :: Monad m => LoopT c e m a -> m e

-- | Call the loop body again and again, passing it the result of the
--   previous iteration each time around. The only way to exit
--   iterateLoopT is to call exit or exitWith.
--   
--   Example:
--   
--   
--   count :: Int -> IO Int
--   count n = iterateLoopT 0 $ \i ->
--       if i < n
--           then do
--               lift $ print i
--               return $ i+1
--           else exitWith i
--   
iterateLoopT :: Monad m => c -> (c -> LoopT c e m c) -> m e

-- | Lift a function like local or mask_.
liftLocalLoopT :: Monad m => (forall a. () => m a -> m a) -> LoopT c e m b -> LoopT c e m b
instance GHC.Internal.Base.Applicative (Control.Monad.Trans.Loop.LoopT c e m)
instance GHC.Internal.Base.Functor (Control.Monad.Trans.Loop.LoopT c e m)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Control.Monad.Trans.Loop.LoopT c e m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Loop.LoopT c e m)
instance GHC.Internal.Base.Monad (Control.Monad.Trans.Loop.LoopT c e m)
instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Loop.LoopT c e)
