This module contains copies of several utilities from Control.Concurrent.Async from the async package, with IO replaced by Process.

Concurrently m a represents a computation of type m a that can be run concurrently with other Concurrently-type computations. It is essentially a copy of the Concurrently applicative from Control.Concurrent.Async, with IO replaced by Process.

Concurrently is an instance of several type classes (see below), but most notable are the instances of Applicative and Alternative. The instances we define are for Concurrently (ReaderT r Process), which in practice means Concurrently Cluster and Concurrently Job.

Applicative instance

The Applicative instance defines for f :: Concurrently m (a->b) and x :: Concurrently m a computations

f <*> x

to be the 'Concurrently m b' computation which is peformed as follows: first, f and x are computed concurrently using concurrently, yielding values of the types a->b and a. Then these values are combined in the obvious way into a value of type b. The implementation of pure x is simply the computation which returns x.

In this way, we can define, for example,

doConcurrently' :: [ Concurrently m a ] -> Concurrently m [a]
doConcurrenlty' [] = pure []
doConcurrenlty' (x:xs) = pure (:) <*> x <*> doConcurrently' xs

which takes a list of computations and returns a computation that performs these computations concurrently and combines their results into a list.

This definition of doConcurrently' works in the following way. The first line is the base for our recursive definition -- an empty list is a trivial computation. The second line will first compute pure (:) -- this is a rather trivial concurrent computation that returns the function (:). We combine this calcuation with x using <*>, which makes it into a calculation that computes the function (:) x', i.e. the function that prepends x' to a list. Here x' is the result of the calculation x. Then we combine this calculation with doConcurrently' xs, which means that we compute (:) x' concurrently with doConcurrently' xs, and then combine the results. The result of doConcurrently' xs will be a list of values, and we prepend x' to it. Recursing into doConcurrently' xs we see that doConcurrently' indeed works by taking a list of computations, performing the calcuations concurrently, and returning the list of results.

We can also define a more convenient function doConcurrently as follows

doConcurrently :: [ m a ] -> m [a]
doConcurrently xs = runConcurrently $ doConcurrently' $ map Concurrently xs

which works by dressing m a in the list in Concurrently, performing doConcurrently' and then finally removing the Concurrently constructor using runConcurrently. The actual definition of doConcurrently is more general, so that it works on any Traversable instance, not just on lists.

Alternative instance

The Alternative instance of Concurrenlty is similar, except it uses race instead of concurrenlty. Specifically,

a <|> b

performs the computations a and b concurrently and returns the result of whichever finishes earlier, using race. The empty implementation is a computation which never returns. In particular,

empty <|> empty

never returns (so is the same as empty, to some extent). We can do, for example

asum [ x, y, z ]

which will run x, y, and z concurrently and return the first returned result, killing the unfinished computations.