| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell98 |
Control.Monad.Loops
Description
A collection of loop operators for use in monads (mostly in stateful ones).
There is a general naming pattern for many of these:
Functions with names ending in _ discard the results of the loop body
as in the standard Prelude mapM functions.
Functions with names ending in ' collect their results into MonadPlus
containers. Note that any short-circuit effect that those types'
MonadPlus instances may provide in a lazy context (such as the instance
for Maybe) will _not_ cause execution to short-circuit in these loops.
Functions with names ending in neither of those will generally return just plain old lists.
- forkMapM :: (a -> IO b) -> [a] -> IO [Either SomeException b]
- forkMapM_ :: (a -> IO b) -> [a] -> IO [Maybe SomeException]
- forkMapM__ :: (a -> IO b) -> [a] -> IO ()
- whileM :: Monad m => m Bool -> m a -> m [a]
- whileM' :: (Monad m, MonadPlus f) => m Bool -> m a -> m (f a)
- whileM_ :: Monad m => m Bool -> m a -> m ()
- iterateWhile :: Monad m => (a -> Bool) -> m a -> m a
- iterateM_ :: Monad m => (a -> m a) -> a -> m b
- untilM :: Monad m => m a -> m Bool -> m [a]
- untilM' :: (Monad m, MonadPlus f) => m a -> m Bool -> m (f a)
- untilM_ :: Monad m => m a -> m Bool -> m ()
- iterateUntilM :: Monad m => (a -> Bool) -> (a -> m a) -> a -> m a
- iterateUntil :: Monad m => (a -> Bool) -> m a -> m a
- whileJust :: Monad m => m (Maybe a) -> (a -> m b) -> m [b]
- whileJust' :: (Monad m, MonadPlus f) => m (Maybe a) -> (a -> m b) -> m (f b)
- whileJust_ :: Monad m => m (Maybe a) -> (a -> m b) -> m ()
- untilJust :: Monad m => m (Maybe a) -> m a
- unfoldM :: Monad m => m (Maybe a) -> m [a]
- unfoldM' :: (Monad m, MonadPlus f) => m (Maybe a) -> m (f a)
- unfoldM_ :: Monad m => m (Maybe a) -> m ()
- unfoldWhileM :: Monad m => (a -> Bool) -> m a -> m [a]
- unfoldWhileM' :: (Monad m, MonadPlus f) => (a -> Bool) -> m a -> m (f a)
- unfoldrM :: Monad m => (a -> m (Maybe (b, a))) -> a -> m [b]
- unfoldrM' :: (Monad m, MonadPlus f) => (a -> m (Maybe (b, a))) -> a -> m (f b)
- concatM :: Monad m => [a -> m a] -> a -> m a
- andM :: Monad m => [m Bool] -> m Bool
- orM :: Monad m => [m Bool] -> m Bool
- anyPM :: Monad m => [a -> m Bool] -> a -> m Bool
- allPM :: Monad m => [a -> m Bool] -> a -> m Bool
- anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool
- allM :: Monad m => (a -> m Bool) -> [a] -> m Bool
- dropWhileM :: Monad m => (a -> m Bool) -> [a] -> m [a]
- trimM :: Monad m => (a -> m Bool) -> [a] -> m [a]
- firstM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
- minimaOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m [a]
- maximaOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m [a]
- minimaByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m [a]
- maximaByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m [a]
- minimaOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m [a]
- maximaOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m [a]
- minimumOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m (Maybe a)
- maximumOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m (Maybe a)
- minimumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m (Maybe a)
- maximumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m (Maybe a)
- minimumOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m (Maybe a)
- maximumOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m (Maybe a)
Documentation
forkMapM :: (a -> IO b) -> [a] -> IO [Either SomeException b] Source
Like mapM, but run all the actions in parallel threads, collecting up
the results and returning them all. Does not return until all actions finish.
forkMapM_ :: (a -> IO b) -> [a] -> IO [Maybe SomeException] Source
like forkMapM but without bothering to keep the return values
forkMapM__ :: (a -> IO b) -> [a] -> IO () Source
like forkMapM_ but not even bothering to track success or failure
of the child threads. Still waits for them all though.
whileM :: Monad m => m Bool -> m a -> m [a] Source
Execute an action repeatedly as long as the given boolean expression returns True. The condition is evaluated before the loop body. Collects the results into a list.
whileM' :: (Monad m, MonadPlus f) => m Bool -> m a -> m (f a) Source
Execute an action repeatedly as long as the given boolean expression
returns True. The condition is evaluated before the loop body.
Collects the results into an arbitrary MonadPlus value.
whileM_ :: Monad m => m Bool -> m a -> m () Source
Execute an action repeatedly as long as the given boolean expression returns True. The condition is evaluated before the loop body. Discards results.
iterateWhile :: Monad m => (a -> Bool) -> m a -> m a Source
Execute an action repeatedly until its result fails to satisfy a predicate, and return that result (discarding all others).
iterateM_ :: Monad m => (a -> m a) -> a -> m b Source
Execute an action forever, feeding the result of each execution as the input to the next.
untilM :: Monad m => m a -> m Bool -> m [a] infixr 0 Source
Execute an action repeatedly until the condition expression returns True.
The condition is evaluated after the loop body. Collects results into a list.
Parameters are arranged for infix usage. eg. do {...} untilM_ ...
untilM_ :: Monad m => m a -> m Bool -> m () infixr 0 Source
Execute an action repeatedly until the condition expression returns True.
The condition is evaluated after the loop body. Discards results.
Parameters are arranged for infix usage. eg. do {...} untilM_ ...
iterateUntilM :: Monad m => (a -> Bool) -> (a -> m a) -> a -> m a infixr 0 Source
Analogue of (
Yields the result of applying f until p holds.until)
iterateUntil :: Monad m => (a -> Bool) -> m a -> m a Source
Execute an action repeatedly until its result satisfies a predicate, and return that result (discarding all others).
whileJust' :: (Monad m, MonadPlus f) => m (Maybe a) -> (a -> m b) -> m (f b) Source
whileJust_ :: Monad m => m (Maybe a) -> (a -> m b) -> m () Source
untilJust :: Monad m => m (Maybe a) -> m a Source
Run the supplied Maybe computation repeatedly until it returns a value. Returns that value.
unfoldWhileM :: Monad m => (a -> Bool) -> m a -> m [a] Source
Repeatedly evaluates the second argument until the value satisfies the given predicate, and returns a list of all values that satisfied the predicate. Discards the final one (which failed the predicate).
unfoldWhileM' :: (Monad m, MonadPlus f) => (a -> Bool) -> m a -> m (f a) Source
Repeatedly evaluates the second argument until the value satisfies
the given predicate, and returns a MonadPlus collection of all values
that satisfied the predicate. Discards the final one (which failed the predicate).
unfoldrM :: Monad m => (a -> m (Maybe (b, a))) -> a -> m [b] Source
See unfoldr. This is a monad-friendly version of that.
unfoldrM' :: (Monad m, MonadPlus f) => (a -> m (Maybe (b, a))) -> a -> m (f b) Source
See unfoldr. This is a monad-friendly version of that, with a
twist. Rather than returning a list, it returns any MonadPlus type of your
choice.
concatM :: Monad m => [a -> m a] -> a -> m a Source
Compose a list of monadic actions into one action. Composes using
(>=>) - that is, the output of each action is fed to the input of
the one after it in the list.
anyPM :: Monad m => [a -> m Bool] -> a -> m Bool Source
short-circuit any with a list of "monadic predicates". Tests the
value presented against each predicate in turn until one passes, then
returns True without any further processing. If none passes, returns False.
allPM :: Monad m => [a -> m Bool] -> a -> m Bool Source
short-circuit all with a list of "monadic predicates". Tests the value
presented against each predicate in turn until one fails, then returns False.
if none fail, returns True.
anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool Source
short-circuit any with a "monadic predicate".
allM :: Monad m => (a -> m Bool) -> [a] -> m Bool Source
short-circuit all with a "monadic predicate".
dropWhileM :: Monad m => (a -> m Bool) -> [a] -> m [a] Source
trimM :: Monad m => (a -> m Bool) -> [a] -> m [a] Source
like dropWhileM but trims both ends of the list.
firstM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a) Source
return the first value from a list, if any, satisfying the given predicate.
minimaOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m [a] Source
maximaOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m [a] Source
minimumOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m (Maybe a) Source
maximumOnByM :: Monad m => (a -> m b) -> (b -> b -> m Ordering) -> [a] -> m (Maybe a) Source
minimumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m (Maybe a) Source
maximumByM :: Monad m => (a -> a -> m Ordering) -> [a] -> m (Maybe a) Source
minimumOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m (Maybe a) Source
maximumOnM :: (Monad m, Ord b) => (a -> m b) -> [a] -> m (Maybe a) Source