Checks if all weights are between 0 and 1.

Creates a new module that exports commonly imported prettyprinter
modules, to cut down on the number of imports each module has to do.

These were originally separated because of some cyclic dependency that
is gone now. So in order to make the module zoo a bit more clear,
merge the two.

This extends the 'help list-functors' command by extensive
documentation on the syntax of functor expressions and coalgebras for
every functor.

It's not really needed.

F seems to be the canonical name for the functor of an F-coalgebra.

It's just more descriptive. The "A" did stand for "approximate", but
only the new Eq instance is approximate, so having that instance is
really the important difference from regular doubles.

1. It will hold more than just the AFloat type in the futeure
2. The name AFloat is confusing anyways

Those functors really require the inverse operation to perform as
required. A separate functor for monoids that aren't groups is
feasable, but would not satisfy the runtime complexity requirements.

The two constructors IntValued and RealValued were a historical
artifact and not at all needed. A general constructor `MonoidValued a`
is all it really takes to implement different parsers for Int and
ADouble.

There has been a long-standing bug, that we only used exact comparison
for IEEE floating point values. This patch implements a newtype
ADouble that wraps `Double` and implements `Eq` approximately using
the library `ieee754`.

The 'help list_functors' command now also shows a small syntax example
for the functor expression of every functor.

This improves running times slightly and may avoid space leaks that
arise from holding on to the labels-list for too long.

This allows to parser more complex expressions in a single
functor (like the polynomial functor), instead of only unary and
binary parsers.

The downside is that implementing a functor parser got more complex:
Each functor now has to call the `inner` parser by itself and also
handle the case where the inner parser succeeds and the outer parser
fails separately.

This design doesn't sound particularly elegant, but there is no
obvious other solution.