Prints a TreeMap in an easy-to-see what's going on way. This code must be pasted inside TreeMap code.

treeMapPrinter.ceylon

    void traverse(Integer level, Node node, MutableMap<Integer, MutableList<Node>> nodes) {
        value list = nodes[level] else ArrayList<Node>();
        nodes.put(level, list);
        list.add(node);

        if (exists l = node.left) {
            print("Left of ``node.key`` is ``l.key``");
            traverse(level + 1, l, nodes);
        }
        if (exists r = node.right) {
            print("Right of ``node.key`` is ``r.key``");
            traverse(level + 1, r, nodes);
        }
    }

    shared void printTree() {
        String pad(String s, Integer size) {
            if (s.size >= size) {
                return s[0:size];
            } else {
                return (" ".repeat((size - s.size) / 2 ) + s + "  ".repeat((size - s.size) / 2))[0:size];
            }
        }
        value builder = StringBuilder();
        if (exists r = root) {
            value nodes = HashMap<Integer, MutableList<Node>>();
            traverse(0, r, nodes);
            print("Nodes: ``nodes.collect((Integer->MutableList<Node> e) => e.key->e.item.collect((Node n) => n.key))`` \n with size ``nodes.size``");
            value maxLevel = nodes.size;
            variable List<Node>? parents = null;
            function sorted(List<Node> nodes) {
                if (nodes.size <= 1) {
                    return true;
                }
                value prev = nodes.first;
                assert(exists prev);
                for (n in nodes.rest) {
                    if (compare(prev.key, n.key) === larger) {
                        print("No way, ``prev.key`` was larger than ``n.key``");
                        return false;
                    }
                }
                return true;
            }
            value even = 2.divides;
            for (index in 0:maxLevel) {
                MutableList<Node>? ns = nodes[index];
                assert(exists ns);
                assert(sorted(ns));
                value padding = 2^(maxLevel + 1 - index);
                variable Integer currChildIndex = 0;
                if (exists p = parents) {
                    variable Integer currParentIndex = 0;
                    for (childIndex in 0:2^index) {
                        value child = ns[currChildIndex];
                        //print("looking at child ``child?.key else "null"`` at level ``currChildIndex``");
                        value parent = p[currParentIndex];
                        if (exists child, exists parent) {
                            if (even(childIndex)) {
                                if (exists l = parent.left, l === child) {
                                    currChildIndex++;
                                    builder.append(pad("``child.key``[``child.red then "R" else "B"``]", padding));
                                } else {
                                    builder.append(pad("?", padding));
                                }
                            } else {
                                if (exists rt = parent.right, rt === child) {
                                    currChildIndex++;
                                    builder.append(pad("``child.key``[``child.red then "R" else "B"``]", padding));

                                } else {
                                    builder.append(pad("?", padding));
                                }
                                currParentIndex++;
                            }
                        } else {
                            builder.append(pad("?", padding));
                        }
                    }
                } else {
                    assert(index == 0);
                    builder.append(pad("``r.key``[``r.red then "R" else "B"``]", padding));
                }
                parents = ns;
                builder.appendNewline();
            }

        }
        print("Here's a tree: \n" + builder.string);
    }