úÎ53žBDescription of concurrent computation with sequential components. (c) Alexander Vieth, 2015BSD3aovieth@gmail.com experimentalnon-portable (GHC only)None !"+-BHM dA witness of this type proves that g is in some sense compatible with IO: we can bind through it.ÅThis corresponds to the notion of a common type of monad transformer: there is some monad g, and then its associated transformer type f, for instance MaybeT = f and Maybe = g If we have an  f m a then we can get an  m (g a) ÌHere we're interested in the special case where we can achieve IO (g a). This does not mean we have to be dealing with an f IO a, it could mean that the IO is buried deeper in the transformer stack! Motivation: Async functions work with IO and only IO , but the m[ parameter of a Concurrential may be some other monad which is capable of performing IO, like Either String IOE for instance. In order to run computations in this moand through Async-, we need to know how to get a hold of an IO. That's what the runner does.aDescription of computation which is composed of sequential and concurrent parts in some monad m.UDescription of the way in which a monadic term's evaluation should be carried out. UOur own Identity functor, so that we don't have to depend upon some other package. cRun a Concurrential term with a continuation. We choose CPS here because it allows us to explot  withAsync\, giving us a guarantee that an exception in a spawning thread will kill spawned threads.YRun a Concurrential term, realizing the effects of the IO-like terms which compose it.9Create an effect 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.…Create an effect 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.   The computation to run.The sequential part.<The continuation; fst is sequential part, snd is value part.WSimilar contract to withAsync; the Async argument is useless outside of this function.         Concurrential-0.4.0.0 Control.Concurrent.Concurrential async-2.0.2Control.Concurrent.AsyncwaitJoinerRunner ConcurrentialrunConcurrentialrunConcurrentialSimple sequentially concurrentlyChoiceIdentityrunConcurrentialKSCApSCBindSCAtom Concurrent Sequential runIdentity SomeAsync waitSomeAsync$fMonadConcurrential$fApplicativeConcurrential$fFunctorConcurrential$fFunctorChoice$fMonadIdentity$fApplicativeIdentity