-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/
-- | Mix concurrent and sequential computation
--
@package Concurrential
@version 0.1.0.0
-- | The functions sequentially and concurrently inject
-- IO terms into the Concurrential monad. This monad's
-- Applicative instance will exploit as much concurrency as possible,
-- much like the Concurrently monad from async, such that all
-- sequentially terms will be run in the order in which they
-- would have been run had they been typical IOs.
module Control.Concurrent.Concurrential
-- | Description of computation which is composed of sequential and
-- concurrent parts.
data Concurrential t
-- | Run a Concurrential term, realizing the effects of the IOs which
-- compose it.
runConcurrential :: Concurrential t -> IO t
-- | Create an IO which must be run sequentially. If a sequentially
-- io appears in a Concurrential t term then it will always
-- be run to completion before any later sequential part of the term is
-- run. Consider the following terms:
--
--
-- a = someConcurrential *> sequentially io *> someOtherConcurrential
-- b = someConcurrential *> concurrently io *> someOtherConcurrential
-- c = someConcurrential *> sequentially io *> concurrently otherIo
--
--
--
-- When running the term a, we are guaranteed that io
-- is completed before any sequential part of
-- someOtherConcurrential is begun, but when running the term
-- b, this is not the case; io may be interleaved with
-- or even run after any part of someOtherConcurrential. The
-- term c highlights an important point: concurrently
-- otherIo may be run before, during or after sequentially
-- io! The ordering through applicative combinators is guaranteed
-- only among sequential terms.
sequentially :: IO t -> Concurrential t
-- | Create an IO which is run concurrently where possible, i.e. whenever
-- it combined applicatively with other terms. For instance:
--
--
-- a = concurrently io *> someConcurrential
-- b = concurrently io >> someConcurrential
--
--
--
-- When running the term a, the IO term io will be run
-- concurrently with someConcurrential, but not so in
-- b, because monadic composition has been used.
concurrently :: IO t -> Concurrential t
instance Monad Concurrential
instance Applicative Concurrential
instance Functor Concurrential
instance Functor Choice