This was the intention all along.

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.

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

This fixes parsing of expressions like ((Z, max)^X) or (Z, max)^(X).

This is much clearer than Max^X

This doesn't satisfy the runtime complexity requirements of the
RefinementInterface correctly, but is useful nontheless.

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.

[skip ci]

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.

Leaving the types entierly abstract is surely more pleasing, but also
the biggest source of slowness.

Slightly faster again..

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.

This changes the transformer stack from `ParserT State` to `StateT
Parser` for these reasons:

1. This allows the state to backtrack with the parser. While this
   shouldn't be necessary for the morphism parser, it's definitely
   less surprising behavior.
2. We need to compose the functor expression and morphism parsers.

This still compiles but doesn't actually work, because the old YAML
parser in src/Parser.hs now returns zero encodings. This parser has to
be replaced next.