A module containing a `Composed`

monad.

The `Composed`

monad can be thought of as an equivalent to functions elsewhere
in chp-plus (especially the Control.Concurrent.CHP.Connect module) that support
partial application of processes when wiring them up.

Binding in this monad can be thought of as "and then wire that like this".
You compose your processes together with a series of monadic actions, feeding
processes into each function that wires up the next parameter, then taking the
results of that action and further wiring it up another way. At the end of
the monadic block you should return the full list of wired-up processes, to
be run in parallel using the `run`

(or `run_`

) functions.

Here is a simple example. You have a list of processes that take an incoming and outgoing channel end and a barrier, and you want to wire them into a cycle and enroll them all on the barrier:

processes :: [Chanin a -> Chanout a -> EnrolledBarrier -> CHP ()] runProcesses = do b <- newBarrier run $ cycleR processes >>= enrollAllR b

The order of the actions in this monad tends not to matter (it is a commutative monad for the most part) so you could equally have written:

processes :: [EnrolledBarrier -> Chanin a -> Chanout a -> CHP ()] runProcesses = do b <- newBarrier run $ enrollAllR b processes >>= cycleR

Remember with this monad to return all the processes to be run in parallel; if they are not returned, they will not be run and you will likely get deadlock.

A little more background on the monad is available in this blog post: http://chplib.wordpress.com/2010/01/19/the-process-composition-monad/

- data Composed a
- runWith :: Composed a -> forall b. (a -> CHP b) -> CHP b
- run :: Composed [CHP a] -> CHP [a]
- run_ :: Composed [CHP a] -> CHP ()
- enrollR :: Enrollable b p => b p -> (Enrolled b p -> a) -> Composed a
- enrollAllR :: Enrollable b p => b p -> [Enrolled b p -> a] -> Composed [a]
- connectR :: Connectable l r => ((l, r) -> a) -> Composed a
- pipelineR :: Connectable l r => [r -> l -> a] -> Composed (r -> l -> [a])
- pipelineCompleteR :: Connectable l r => (l -> a) -> [r -> l -> a] -> (r -> a) -> Composed [a]
- cycleR :: Connectable l r => [r -> l -> a] -> Composed [a]
- wrappedGridFourR :: (Connectable below above, Connectable right left) => [[FourWay above below left right -> a]] -> Composed [[a]]

# Documentation

A monad for composing together CHP processes in cross-cutting ways; e.g. wiring together a list of processes into a pipeline, but also enrolling them all on a barrier.

run :: Composed [CHP a] -> CHP [a]Source

Given a list of CHP processes composed using the Composed monad, runs them
as a parallel bunch of CHP results (with `runParallel`

) and returns the results.

enrollR :: Enrollable b p => b p -> (Enrolled b p -> a) -> Composed aSource

enrollAllR :: Enrollable b p => b p -> [Enrolled b p -> a] -> Composed [a]Source

Given an `Enrollable`

item (such as a `Barrier`

), and a list of processes,
composes them by enrolling them all on the given barrier.

connectR :: Connectable l r => ((l, r) -> a) -> Composed aSource

pipelineR :: Connectable l r => [r -> l -> a] -> Composed (r -> l -> [a])Source

Wires a list of processes into a pipeline that takes the two channels for the ends of the pipeline and returns the list of wired-up processes.

pipelineCompleteR :: Connectable l r => (l -> a) -> [r -> l -> a] -> (r -> a) -> Composed [a]Source

cycleR :: Connectable l r => [r -> l -> a] -> Composed [a]Source

Connects together a list of processes into a cycle.

wrappedGridFourR :: (Connectable below above, Connectable right left) => [[FourWay above below left right -> a]] -> Composed [[a]]Source

Like `wrappedGridFour`

, but in the `Composed`

monad.