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
- 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 ()
- 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 ()
- 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 ()
- 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)
- atomLoop :: STM a -> IO ()
- forkAtomLoop :: STM a -> IO ThreadId
- waitFor :: (a -> Bool) -> STM a -> STM a
- waitForTrue :: STM Bool -> STM ()
- waitForEvent :: (a -> Bool) -> TChan a -> STM 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 aSource
Execute an action repeatedly until its result fails to satisfy a predicate, and return that result (discarding all others).
untilM :: Monad m => m a -> m Bool -> m [a]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 ()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_
...
iterateUntil :: Monad m => (a -> Bool) -> m a -> m aSource
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
unfoldrM :: Monad m => (a -> m (Maybe (b, a))) -> a -> m [b]Source
See Data.List.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 Data.List.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 aSource
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 BoolSource
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 BoolSource
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 BoolSource
short-circuit any
with a "monadic predicate".
allM :: Monad m => (a -> m Bool) -> [a] -> m BoolSource
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.