'#' starts a line comment and skips the rest of the line.

We need this to print the final result with the names defined in the
input file instead of the internal node representations (ints).

Use parseErrorPretty instead of show

This was just there to ease the transition into the new functors
framework. Now that's done, it can be removed.

Since we now have all blocks in the same partition, we can finally fix
the type of split to be more intuitively related to the printed
version.

Instead of one big Algorithm.hs, there are now separate modules for
`initialize`, `split` and the queue handling stuff. This hopefully
makes the code structure a little more clear and also allows us to
export utility functions (like `initialize` and `split`) from
submodules for testing, while still keeping a tidy export list in the
toplevel module.

If needed, Show should be required at a different place.
RefinementInterface should now represent exactly what's described in
the paper.

Still not used by the algorithm, but at a step in the right
direction...

This hooks the new machinery into the old algorithm, but it's still
not finished.

- Sorts are currenly silently ignored when constructing the initial
  partitions (which should lead to wrong results).
- We do a little dance to feed the algorithm that expects a Vector of
  encodings a single encoding for a desorted functor expression.
- Examples in the source should be converted to the new format.

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.

Instead of expecting `ParserT` to be at the top of the monad stack,
they now only assume that the monad satisfies the `MonadParser`
constraint, allowing to use them unlifted in `StateT Parser`

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.

This was only done to test if the specification catches any problems
and was then accidentally committed.

The RefinementInterface class contained several type families (or
associated types) like Weight or H1. It turns out that we also need
these definitions in other classes and to avoid unnecessary
dependencies between those type classes and RefinementInterface, the
type families now have their own home in RefinementTypes.hs.

Now, the morphism parser directly returns (Sort, h1) instead of h1,
lifting the burden of sort-tracking from SomeFunctor.

This is still not final and has several API problems. E.g implementing
ParseMorphism for SomeFunctor is currently not possible without a
warning about unimplemented methods.

Implements a new morphism parser that doesn't depend on yaml and has
much nicer properties in "MA.Coalgebra.Parser".

This is not yet complete:

  - Needs more testing
  - Needs to handle special cases better
  - Needs a way for SomeFunctor to retrieve it's own sort

I use this almost everywhere I used monads