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


-- | Fork of the monad-parallel package using monad-control
--   
--   Fork of the monad-parallel package using monad-control
@package classy-parallel
@version 0.1.0.0


-- | 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, <a>Parallel</a> and
--   <a>Fork</a>. 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 <a>forkExec</a>. The function
--   immediately returns a handle to the running computation. The handle
--   can be used to obtain the result of the computation when needed:
--   
--   <pre>
--   do child &lt;- forkExec expensive
--      otherStuff
--      result &lt;- child
--   </pre>
--   
--   In this example, the computations <i>expensive</i> and
--   <i>otherStuff</i> would be performed in parallel. When using the
--   <a>Parallel</a> class, both parallel computations must be specified at
--   once:
--   
--   <pre>
--   bindM2 (\ childResult otherResult -&gt; ...) expensive otherStuff
--   </pre>
--   
--   In either case, for best results the costs of the two computations
--   should be roughly equal.
--   
--   Any monad that is an instance of the <a>Fork</a> class can also be
--   instance of the <a>Parallel</a> class by the following rule:
--   
--   <pre>
--   bindM2 f ma mb = do {a' &lt;- forkExec ma; b &lt;- mb; a &lt;- a'; f a b}
--   </pre>
--   
--   When operating with monads free of side-effects, such as
--   <a>Identity</a> or <a>Maybe</a>, <a>forkExec</a> is equivalent to
--   <a>return</a> and <a>bindM2</a> is equivalent to <tt> \ f ma mb -&gt;
--   do {a &lt;- ma; b &lt;- mb; f a b} </tt> — the only difference is in
--   the resource utilisation. With the <a>IO</a> monad, on the other hand,
--   there may be visible difference in the results because the side
--   effects of <i>ma</i> and <i>mb</i> may be arbitrarily reordered.
module Control.Monad.Parallel

-- | Class of types that can perform two computations in parallel and bind
--   their results together.
class Monad m => Parallel m
bindM2 :: Parallel m => (a -> b -> m c) -> m a -> m b -> m c

-- | Class of monads that can fork a parallel computation.
class Monad m => Fork m
forkExec :: Fork m => m a -> m (m a)

-- | Perform three monadic computations in parallel; when they are all
--   finished, pass their results to the function.
bindM3 :: Parallel m => (a -> b -> c -> m d) -> m a -> m b -> m c -> m d

-- | Like <a>liftM2</a>, but evaluating its two monadic arguments in
--   parallel.
liftM2 :: Parallel m => (a -> b -> c) -> m a -> m b -> m c

-- | Like <a>liftM3</a>, but evaluating its three monadic arguments in
--   parallel.
liftM3 :: Parallel m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r

-- | Like <a>ap</a>, but evaluating the function and its argument in
--   parallel.
ap :: Parallel m => m (a -> b) -> m a -> m b

-- | Like <a>sequence</a>, but executing the actions in parallel.
sequence :: Parallel m => [m a] -> m [a]

-- | Like <a>sequence_</a>, but executing the actions in parallel.
sequence_ :: Fork m => [m a] -> m ()

-- | Like <a>mapM</a>, but applying the function to the individual list
--   items in parallel.
mapM :: Parallel m => (a -> m b) -> [a] -> m [b]

-- | Like <a>replicateM</a>, but executing the action multiple times in
--   parallel.
replicateM :: Parallel m => Int -> m a -> m [a]

-- | Like <a>replicateM_</a>, but executing the action multiple times in
--   parallel.
replicateM_ :: Fork m => Int -> m a -> m ()
defaultForkExec :: Monad m => m a -> (m (m a))
defaultBindM2 :: Monad m => (a -> b -> m c) -> m a -> m b -> m c

-- | Common bind pattern for monad transformers
bindTrans :: (MonadTransControl t, Parallel m, Monad m, Monad (t m)) => (a -> b -> t m c) -> t m a -> t m b -> t m c
forkTrans :: (MonadTransControl t, Fork m) => t m a -> t m (t m a)

-- | Defines <a>bindM2</a> in terms of <a>forkExec</a>
parallelIO :: Fork m => (a -> b -> m c) -> m a -> m b -> m c
instance Fork (ResourceT IO)
instance Fork IO
instance Fork ((->) r)
instance Fork []
instance Fork Maybe
instance Parallel m => Parallel (ReaderT r m)
instance Parallel m => Parallel (ListT m)
instance (Parallel m, Error e) => Parallel (ErrorT e m)
instance Parallel m => Parallel (MaybeT m)
instance Parallel m => Parallel (IdentityT m)
instance Parallel (ResourceT IO)
instance Parallel IO
instance Parallel ((->) r)
instance Parallel []
instance Parallel Maybe
instance Parallel Identity