## The Operators and Monoids of CHP

When we create binary operators, in mathematics or in programming, they often have certain common identifiable properties:

- If you can re-order the arguments, e.g. 1 + 2 is the same as 2 + 1, we say that it is
**commutative**— in contrast, division is not commutative. - If you have two applications of the operator and the order of evaluation/bracketing doesn’t matter, e.g. (1 + 2) + 3 is the same as 1 + (2 + 3), we say that it is
**associative**— in contrast, subtraction is not associative. - If one particular operand always leaves the other side unchanged, we can say that this is the
**unit**of an operator, e.g. 1 * x is the same as x, so 1 is the unit of multiplication. - If one particular operand always ignores/overrides the other, we can say that this is the
**zero**of an operator, e.g. 0 * x is the same as 0, so 0 is the zero of multiplication. - If an operator has a unit or zero that only works on one side of the operator, we name it accordingly. For example, we say that division has a right-unit of 1 (because x / 1 is the same as x), but it does not have a left-unit; there is no value k such that for all x, k / x is the same as x.

We can find these properties all over maths and programming. Set union is commutative, associative, and has a unit of the empty set, but no zero. The boolean AND operator is commutative, associative, has the unit “true” and the zero “false”. STM’s orElse combinator is associative, with the unit retry, and the left-zero of a return statement. Any operator that is associative and has a unit forms a monoid, which can be put into Haskell as an instance of the Monoid type-class (more on that below).

The operators in CHP also have some of the aforementioned properties. A full list is buried at the back of the tutorial, but I should probably pull them into the API documentation. (Note that the laws I discuss here are concerned with the behavioural semantics of the operators; the types of the expressions may differ trivially.) The parallel operator `<||>` is commutative and associative, with a unit of `skip`, the process that does nothing and returns successfully. The unprioritised choice operator `<->` is commutative and associative, with a unit of `stop`, the process that is never ready in a choice. The implication of choice and parallelism being associative and commutative is that the order of the items in a call to `alt` or `runParallel` doesn’t make any difference to the behaviour. The operators for wiring up a pipeline in the Utils module are associative but lack the other properties.

#### Poison Handler Properties

We can view the poison handlers ``onPoisonTrap`` and ``onPoisonRethrow`` as binary operators. To recap: ``onPoisonTrap`` runs the left-hand side, but if a poison exception occurs then the right-hand side is run. ``onPoisonRethrow`` does the same, but after the right-hand side has finished, the poison exception is rethrown. They are not commutative — in exception terminology, the first argument is the try and the second the catch; they cannot be swapped freely!

To my surprise, ``onPoisonTrap`` is associative. Abbreviating it to ``oPT``, consider `p `oPT` q `oPT` r`. If you bracket the first two items,

`(p`, q will only execute if p throws poison, and r will only execute if q then throws poison (because p’s poison is trapped, so the only poison that can escape the first bracket is from q). If you bracket the latter two,

``oPT``q)``oPT``r`p`, the brackets will only execute if p throws poison, which will pass control to q, which will only pass control to r if poison is thrown by q. So the semantics are associative.

``oPT``(q``oPT``r)In contrast, ``onPoisonRethrow`` is not associative. Abbreviating it to ``oPR``, consider: `p `oPR` skip `oPR` r`. If bracketed

`(p`, r will be executed if p poisons, but if bracketed

``oPR``skip)``oPR``r`p`, r will never be executed (because skip won’t throw poison).

``oPR``(skip``oPR``r)``onPoisonTrap`` has a left-unit of `throwPoison` (because throwing poison automatically transfers control to the other side, the handler), and a right-unit of `throwPoison` (because trapping poison then throwing poison has a null effect on the original code). ``onPoisonRethrow`` has no left-unit but has two right-units: `throwPoison` and the return statement. Any code that cannot throw poison (e.g. a return statement) is a left-zero of both ``onPoisonTrap`` and ``onPoisonRethrow`` because it will never trigger the handler. Neither operator has a right-zero; there is no handler that can cause the original code to always be ignored.

#### Monoids

The fact that some of the operators mentioned here are associative and have units mean that they could form a monoid. In fact, CHP blocks of code could form several monoids. In Haskell, there is the problem that the monoid instance must be uniquely identified by its type, even though it is really its operator that is distinctive. All the standard number types can form a `Monoid` in addition (unit: 0, operator: +) or multiplication (unit: 1, operator: *). Defining a Monoid instance for, say, `Int` would thus be ambigious: when you say `4 `mappend` 3`, would you expect 7 or 12? To solve this, the Data.Monoid module defines newtype-wrappers around types to identify the monoid. `Sum Int` is a monoid in addition, whereas `Product Int` is a monoid in multiplication.

I could use the same trick for CHP; I could define several monoid instances. Here is a monoid that allows blocks of code (with no useful return) to be joined in parallel:

newtype Par = Par {runPar :: CHP ()} instance Monoid Par where mempty = Par skip mappend p q = Par (runPar p<|*|>runPar q) mconcat = Par.runParallel_.map runPar

This could be made a little more useful by making a parallel monoid out of blocks of code that return a type that is itself a monoid; when the parallel blocks of code have all finished, their results are combined using the monoid instance:

newtype ParMonoid a = ParMonoid {runParMonoid :: CHP a} instance Monoid a => Monoid (ParMonoid a) where mempty = ParMonoid (return mempty) mappend p q = ParMonoid (liftM (uncurry mappend)$runParMonoid p<||>runParMonoid q) mconcat = ParMonoid.liftM mconcat.runParallel.map runParMonoid

There is also a straightforward monoid instance for choice between blocks:

newtype Alt a = Alt {runAlt :: CHP a} instance Monoid (Alt a) where mempty = Alt stop mappend a b = Alt (runAlt a<->runAlt b) mconcat = Alt.alt.map runAlt

Finally, there is a monoid built around ``onPoisonTrap``:

newtype PoisonTrap a = PoisonTrap {runPoisonTrap :: CHP a} instance Monoid (PoisonTrap a) where mempty = PoisonTrapthrowPoisonmappend a b = PoisonTrap (runPoisonTrap a`onPoisonTrap`runPoisonTrap b)

Consider the meaning of `mconcat (map PoisonTrap [p,q,r,s])`. It says run p; if no poison is thrown, that’s done. If poison is thrown, run q. If q throws poison, run r, and if that throws a poison, run s. Obviously this is quite excessive, but I had never thought of constructing such a function until I realised that ``onPoisonTrap`` was associative and thus could form a monoid.

I can’t recall seeing monoid instances like these (involving monadic actions), so perhaps these sorts of monoid instances on monads don’t end up being very useful (if you know of a particular use, please add a comment below). I find it interesting to see how CHP code can form several different monoids just as an exercise.

my impression was that both Alternative and MonadPlus are used to capture monoids on monads. Alternative idiomatically being used to capture choice, and MonadPlus to capture union.

Alternative does look like a good fit for my alt construct (and the names match, too). I should probably add an instance in future, thanks.

I have a few monoids of monadic actions in hackage under

http://hackage.haskell.org/packages/archive/monoids/0.2.0.2/doc/html/Data-Monoid-Monad.html

but they are only for the obvious cases.

I use them to build up useful folds over monomorphic Foldable-like containers:

http://hackage.haskell.org/packages/archive/monoids/0.2.0.2/doc/html/Data-Generator-Combinators.html