Retire the visitor

import java.util.*;

/**
 * CHALLENGE — 20 minutes.
 *
 * A document model written the way it had to be written before Java 17: an
 * open interface plus a visitor, because the visitor was the only way to get
 * the compiler to tell you about a case you forgot.
 *
 * It works. It is also about four times as much code as the same thing needs
 * today, and the indirection makes the render logic hard to read in one pass.
 *
 * TASKS
 *   1. Run it and read the output, so you know what to preserve.
 *   2. Seal Node, make the three implementations records, and rewrite
 *      render() as a single exhaustive switch expression with no default.
 *   3. Delete Visitor, accept(), and the visit overloads.
 *   4. Add a fourth node type (Quote, say) and confirm the compiler points
 *      straight at render().
 *   5. In a comment: name one situation where you would still choose the
 *      visitor. There is a real one — the case list lives in a different
 *      place, and sometimes that is what you want.
 */
public class Starter {

    interface Node {
        <R> R accept(Visitor<R> visitor);
    }

    interface Visitor<R> {
        R visitText(Text text);

        R visitBold(Bold bold);

        R visitBranch(Branch branch);
    }

    static final class Text implements Node {
        final String value;

        Text(String value) { this.value = value; }

        @Override public <R> R accept(Visitor<R> visitor) { return visitor.visitText(this); }
    }

    static final class Bold implements Node {
        final Node inner;

        Bold(Node inner) { this.inner = inner; }

        @Override public <R> R accept(Visitor<R> visitor) { return visitor.visitBold(this); }
    }

    static final class Branch implements Node {
        final List<Node> children;

        Branch(List<Node> children) { this.children = children; }

        @Override public <R> R accept(Visitor<R> visitor) { return visitor.visitBranch(this); }
    }

    /** Everything below here should end up as one switch expression. */
    static final class HtmlRenderer implements Visitor<String> {
        @Override
        public String visitText(Text text) {
            return text.value;
        }

        @Override
        public String visitBold(Bold bold) {
            return "<b>" + bold.inner.accept(this) + "</b>";
        }

        @Override
        public String visitBranch(Branch branch) {
            StringBuilder out = new StringBuilder();
            for (Node child : branch.children) {
                out.append(child.accept(this));
            }
            return out.toString();
        }
    }

    static String render(Node node) {
        return node.accept(new HtmlRenderer());
    }

    public static void main(String[] args) {
        Node document = new Branch(List.of(
                new Text("Interviews reward "),
                new Bold(new Text("depth")),
                new Text(", not recall.")));

        System.out.println(render(document));
    }
}