This means that "Xfoo" won't parse, but "X" will. Previously, non-parsable
suffixes had been ignored.

This warning is really annoying.

This allows to write separate tests for the library.

This allows tests to depend on the library, leading to shorter compile times
cleaner boundaries.

This will allow to use multiple internal libraries, which can be used to add
tests for other executables than the main one.

Unfortunately, cabal-doctest is currently not supported in combination with
internal libraries and so I had to temporarily disable doctests.

This speeds up the build process of the main copar executable and doesn't
require as much dependencies.

As more and more benchmark suite generators are created, results published and
the tools forgotten, this creates an unnecessary burden on the everyday compile
cycle.

The current way of iterating trough all possible edges and deciding for each
edge if we take it or not has proven not to scale to large but sparse graphs.

Instead, we now generate the edges that we want directly.

This already does all we need, so instead of duplicating the whole
implementation, just use it.

This switches from floats to a sort of arbitrary precision base10 floating point
implementation where we can easily generate uniform random numbers.

The problem with floats is that they aren't distributed equally across the whole
range and thus a random number in [0, 1) is not uniform.

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.

This splits the previous stat values "refine-duration" into
"initialize-duration" and "refine-duration". The sum of those (plus
measurement overhead, etc) is still reported as "algorithm-duration".

ma -> copar

While AbsorbingPolynomial has brought down the running time in many
cases, it unfortunately required quite a bit more memory than the old
Polynomial, even though the number of states and edges was reduced.
The problem here was that:

1. The overall number of labels, weights and H1 values was _not_
   reduced, they were just moved into the corresponding type of
   AbsorbingPolynomial. The only thing saved was the `Sorted` layer on
   the inner data.

2. On the flip side, the old Polynomial implementation could use very
   memory efficient unboxed vectors for nearly everything, whereas
   AbsorbingPolynomial has to store wrapped SomeFunctor values (which
   are not unboxable).

This is now solved by being very memory conscious in the
implementation of Label, H1, H3 and Weight for AbsorbingPolynomial.
E.g we use the primitive SmallArray type instead of Vector and try to
avoid indirections introduced by Maybe or Either wrappers wherever
possible.

These are just the tests originally from Polynomial. Some of them are
failing right now.

Moves the transformations on functor expressions out of the
SomeFunctor definition. This was really conflating two unrelated
purposes and the new design is hopefully much cleaner.

There is now `MA.RewriteFunctors`, which is intended to be a
collection of rewrite rules on the functor expression, including the
existing polynomial->absorbingpolynomial one.