-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Parallel execution of monadic computations
--
-- This package defines classes of monads that can perform multiple
-- executions in parallel and combine their results. For any monad that's
-- an instance of the class, the package re-implements a subset of the
-- Control.Monad interface, but with parallel execution.
@package monad-parallel
@version 0.8
-- | This module defines classes of monads that can perform multiple
-- computations in parallel and, more importantly, combine the results of
-- those parallel computations.
--
-- There are two classes exported by this module, MonadParallel
-- and MonadFork. The former is more generic, but the latter is
-- easier to use: when invoking any expensive computation that could be
-- performed in parallel, simply wrap the call in forkExec. The
-- function immediately returns a handle to the running computation. The
-- handle can be used to obtain the result of the computation when
-- needed:
--
--
-- do child <- forkExec expensive
-- otherStuff
-- result <- child
--
--
-- In this example, the computations expensive and
-- otherStuff would be performed in parallel. When using the
-- MonadParallel class, both parallel computations must be
-- specified at once:
--
--
-- bindM2 (\ childResult otherResult -> ...) expensive otherStuff
--
--
-- In either case, for best results the costs of the two computations
-- should be roughly equal.
--
-- Any monad that is an instance of the MonadFork class is also an
-- instance of the MonadParallel class, and the following law
-- should hold:
--
--
-- bindM2 f ma mb = do {a' <- forkExec ma; b <- mb; a <- a'; f a b}
--
--
-- When operating with monads free of side-effects, such as
-- Identity or Maybe, forkExec is equivalent to
-- return and bindM2 is equivalent to \ f ma mb ->
-- do {a <- ma; b <- mb; f a b} — the only difference is in
-- the resource utilisation. With the IO monad, on the other hand,
-- there may be visible difference in the results because the side
-- effects of ma and mb may be arbitrarily reordered.
module Control.Monad.Parallel
-- | Class of monads that can perform two computations in parallel and bind
-- their results together.
class Monad m => MonadParallel m
-- | Perform two monadic computations in parallel; when they are both
-- finished, pass the results to the function. Apart from the possible
-- ordering of side effects, this function is equivalent to \f ma
-- mb-> do {a <- ma; b <- mb; f a b}
bindM2 :: MonadParallel m => (a -> b -> m c) -> m a -> m b -> m c
-- | Class of monads that can fork a parallel computation.
class MonadParallel m => MonadFork m
-- | Fork a child monadic computation to be performed in parallel with the
-- current one.
forkExec :: MonadFork m => m a -> m (m a)
-- | Perform three monadic computations in parallel; when they are all
-- finished, pass their results to the function.
bindM3 :: MonadParallel m => (a -> b -> c -> m d) -> m a -> m b -> m c -> m d
-- | Like ap, but evaluating the function and its argument in
-- parallel.
ap :: MonadParallel m => m (a -> b) -> m a -> m b
-- | Like forM, but applying the function to the individual list
-- items in parallel.
forM :: MonadParallel m => [a] -> (a -> m b) -> m [b]
-- | Like forM_, but applying the function to the individual list
-- items in parallel.
forM_ :: MonadParallel m => [a] -> (a -> m b) -> m ()
-- | Like liftM2, but evaluating its two monadic arguments in
-- parallel.
liftM2 :: MonadParallel m => (a -> b -> c) -> m a -> m b -> m c
-- | Like liftM3, but evaluating its three monadic arguments in
-- parallel.
liftM3 :: MonadParallel m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
-- | Like mapM, but applying the function to the individual list
-- items in parallel.
mapM :: MonadParallel m => (a -> m b) -> [a] -> m [b]
-- | Like mapM_, but applying the function to the individual list
-- items in parallel.
mapM_ :: MonadParallel m => (a -> m b) -> [a] -> m ()
-- | Like replicateM, but executing the action multiple times in
-- parallel.
replicateM :: MonadParallel m => Int -> m a -> m [a]
-- | Like replicateM_, but executing the action multiple times in
-- parallel.
replicateM_ :: MonadParallel m => Int -> m a -> m ()
-- | Like sequence, but executing the actions in parallel.
sequence :: MonadParallel m => [m a] -> m [a]
-- | Like sequence_, but executing the actions in parallel.
sequence_ :: MonadParallel m => [m a] -> m ()
instance Control.Monad.Parallel.MonadParallel GHC.Types.IO
instance Control.Monad.Parallel.MonadFork GHC.Maybe.Maybe
instance Control.Monad.Parallel.MonadFork []
instance Control.Monad.Parallel.MonadFork ((->) r)
instance Control.Monad.Parallel.MonadFork GHC.Types.IO
instance Control.Monad.Parallel.MonadFork m => Control.Monad.Parallel.MonadFork (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Parallel.MonadFork m => Control.Monad.Parallel.MonadFork (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.Parallel.MonadFork m => Control.Monad.Parallel.MonadFork (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Parallel.MonadFork m => Control.Monad.Parallel.MonadFork (Control.Monad.Trans.Reader.ReaderT r m)
instance Control.Monad.Parallel.MonadParallel Data.Functor.Identity.Identity
instance Control.Monad.Parallel.MonadParallel GHC.Maybe.Maybe
instance Control.Monad.Parallel.MonadParallel []
instance Control.Monad.Parallel.MonadParallel ((->) r)
instance Control.Monad.Parallel.MonadParallel m => Control.Monad.Parallel.MonadParallel (Control.Monad.Trans.Identity.IdentityT m)
instance Control.Monad.Parallel.MonadParallel m => Control.Monad.Parallel.MonadParallel (Control.Monad.Trans.Maybe.MaybeT m)
instance Control.Monad.Parallel.MonadParallel m => Control.Monad.Parallel.MonadParallel (Control.Monad.Trans.Except.ExceptT e m)
instance Control.Monad.Parallel.MonadParallel m => Control.Monad.Parallel.MonadParallel (Control.Monad.Trans.Reader.ReaderT r m)