A queue for sorted blocks that has O(1) membership test, enqueue and
dequeue.

The type `h` was only needed to make instance resolution unambiguous,
but type application can do that, too.

This completes phase 3 of split(). What's left is the queue handling
and actually testing the code (which isn't possible until the queue is
implemented).

We need to sort according to H3...

This adds a new target 'doctests' that checks examples in
documentation comments.

This will be needed to be able to do monadic array lookups in the the
predicate function.

After changing RefinablePartition.statesOfBlock from list to vector,
tests failed to compile.

The order of arguments to Vector.slice was accidentally reversed,
leading to random results.

I forgot this when I changed the RefinementInterface context to
require Eq for H3... A working CI would have found it.

This is monadic code and not lazy, so a vector is more
memory/allocation and thus runtime efficient.

This completes the second phase of the split algorithm: Compute new
weights, update the lastW array and unmark states with zero weight.

This is still all untested...

This is needed to be able to iterate over marked states instead of
just using them for splitting.

We will need this because we initially mark states that have v^x ==
v_0 and need to unmark those again later.

Untested: This implements one half of the split algorithm.

Fixes the type used for W and introduces descriptive names for the
constructors of Three to make the intent clearer.

This is copy pasta from another project.

This allows to initialize the algorithm not only for one but for all
morphisms and is needed to test initialization from main.

It's needed in other modules than the parser

This type should only be an artifact of the fromJSON machinery.

Previously, this was already computed in Encoding.new. But since
`pred` requires knowledge about the size of the target set, this is
much better done in the init phase.

This file is used as local emacs configuration

Instead of letting each individual functor parse the whole morphism,
only let them influence the parsing of individual mappings.

This helps with debugging, because it formats the `show` output with
more newlines and colors.