The processing function (a -> x -> m x) must act as if purely, so that indeed for a given input the
output is always the same. One particular thing to be careful with is that the output does not depend
on time (for example, you shouldn't use IOProcessor to implement an input device). The IOSource type
is defined exactly for time-dependent processors. For pointer typed inputs and outputs, see next law.

For processors that work on pointers, [[ Ptr t ]] = t. This is guaranteed by the following
implementation constraints for IOProcessor a b:

If a is a pointer type (a = Ptr p), then the processor must NOT write (modify) the referenced data.

If b is a pointer, the memory it points to (and its allocation status) is only allowed to change
by the processor that created it (in the processing and releasing functions). In a way this
generalizes the first constraint.

Note, that unlike Yampa, this model does not allow transformations of the type (Time -> a) -> (Time ->
b). The reason is that I want to prevent arbitrary time access (whether causal or not). This limitation
means that everything is essentially point-wise in time. To allow memory-full operations under this
model, scanlT is defined. See http://www.ee.bgu.ac.il/~noamle/_downloads/gaccum.pdf for more about
arbitrary time access.

Thus, it is ok to implement a processing action that outputs arbitrary time-dependent values during runtime
regardless of input. (Although the more useful case is to calculate something from the input a that is
also time-dependent. The a input is often not required and in those cases a = () is used.

Notice that this means that IOSource doesn't qualify as an IOProcessor. However, currently the
implementation does NOT enforce this, i.e. IOSource is not a newtype; I don't know how to implement it
correctly. Also, one question is whether primitives like chain will have to disallow placing IOSource
as the second element in a chain. Maybe they should, maybe they shouldn't.