Control.Concurrent.Concurrential

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.

Documentation

data Concurrential t

Description of computation which is composed of sequential and concurrent parts.

Instances

Monad Concurrential

Functor Concurrential

Applicative Concurrential

runConcurrential :: Concurrential t -> IO t

Run a Concurrential term, realizing the effects of the IOs which compose it.

sequentially :: IO t -> Concurrential 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.

concurrently :: 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.