Runs a CHP program. You should use this once, at the top-level of your
program. Do not ever use this function twice in parallel and attempt to
communicate between those processes using channels. Instead, run this function
once and use it to spawn off the parallel processes that you need.

Allows embedding of the CHP monad back into the IO monad. The argument
that this function takes is a CHP action (with arbitrary behaviour). The
function is monadic, and returns something of type: IO a. This
is an IO action that you can now use in the IO monad wherever you like.
What it returns is the result of your original action.

This function is intended for use wherever you need to supply an IO callback
(for example with the OpenGL libraries) that needs to perform CHP communications.
It is the safe way to do things, rather than using runCHP twice (and also works
with CSP and VCR traces -- but not structural traces!).

Like onPoisonTrap, this function allows you to provide a handler
for poison. The difference with this function is that even if the
poison handler does not throw, the poison exception will always be
re-thrown after the handler anyway. That is, the following lines of
code all have identical behaviour:

Primitive actions

The stop guard. Its main use is that it is never ready in a choice, so
can be used to mask out guards. If you actually execute stop, that process
will do nothing more. Any parent process waiting for it to complete will
wait forever.

Waits for the specified number of microseconds (millionths of a second).
There is no guaranteed precision, but the wait will never complete in less
time than the parameter given.

Suitable for use in an Control.Concurrent.CHP.Alt.alt, but note that waitFor 0 is not the same
as skip. waitFor 0 Control.Concurrent.CHP.Alt.</> x will not always select the first guard,
depending on x. Included in this is the lack of guarantee that
waitFor 0 Control.Concurrent.CHP.Alt.</>waitFor n will select the first guard for any value
of n (including 0). It is not useful to use two waitFor guards in a
single Control.Concurrent.CHP.Alt.alt anyway.

NOTE: If you wish to use this as part of a choice, you must use -threaded
as a GHC compilation option (at least under 6.8.2).