Data-oriented programming with records

expr/Expr.java

/**
 * A small arithmetic language as data: a sealed interface and five records, with no behaviour at all. The records sit
 * in this file, so the interface needs no permits clause: javac permits exactly these five.
 */
sealed interface Expr {}

record Num(int value) implements Expr {}
record Var(String name) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}
record Mul(Expr left, Expr right) implements Expr {}
record Neg(Expr operand) implements Expr {}

expr/Calc.java

import java.util.Map;

/** The operations on Expr: each one a switch with a case for every record, and no default. */
final class Calc {
    private Calc() {}

    /** The value of an expression, with the value of each variable taken from env. */
    static int eval(Expr e, Map<String, Integer> env) {
        return switch (e) {
            case Num(int value) -> value;
            case Var(String name) -> lookup(name, env);
            case Add(Expr left, Expr right) -> eval(left, env) + eval(right, env);
            case Mul(Expr left, Expr right) -> eval(left, env) * eval(right, env);
            case Neg(Expr operand) -> -eval(operand, env);
        };
    }

    /** The expression with every bracket written out, such as ((1 * x) + 0). */
    static String text(Expr e) {
        return switch (e) {
            case Num(int value) -> Integer.toString(value);
            case Var(String name) -> name;
            case Add(Expr left, Expr right) -> "(" + text(left) + " + " + text(right) + ")";
            case Mul(Expr left, Expr right) -> "(" + text(left) + " * " + text(right) + ")";
            case Neg(Expr operand) -> "(-" + text(operand) + ")";
        };
    }

    /** Simplifies the children first, then tries one rule on the node itself. */
    static Expr simplify(Expr e) {
        return switch (e) {
            case Num _, Var _ -> e;
            case Add(Expr left, Expr right) -> rule(new Add(simplify(left), simplify(right)));
            case Mul(Expr left, Expr right) -> rule(new Mul(simplify(left), simplify(right)));
            case Neg(Expr operand) -> rule(new Neg(simplify(operand)));
        };
    }

    /** The rewrite rules: nested record patterns, some with a guard. Most nodes match none and stay as they are. */
    private static Expr rule(Expr e) {
        return switch (e) {
            case Add(Num(int a), Num(int b)) -> new Num(a + b);
            case Mul(Num(int a), Num(int b)) -> new Num(a * b);
            case Add(Expr x, Num(int n)) when n == 0 -> x;
            case Add(Num(int n), Expr x) when n == 0 -> x;
            case Mul(Expr x, Num(int n)) when n == 1 -> x;
            case Mul(Num(int n), Expr x) when n == 1 -> x;
            case Mul(_, Num(int n)) when n == 0 -> new Num(0);
            case Mul(Num(int n), _) when n == 0 -> new Num(0);
            case Neg(Num(int value)) -> new Num(-value);
            case Neg(Neg(Expr x)) -> x;
            default -> e;
        };
    }

    private static int lookup(String name, Map<String, Integer> env) {
        Integer value = env.get(name);
        if (value == null) throw new IllegalArgumentException("no value for " + name);
        return value;
    }
}

expr/Main.java

/** Four expressions: each one printed, simplified and evaluated with x = 5 and y = 7. */
void main() {
    var x = new Var("x");
    var y = new Var("y");
    List<Expr> expressions = List.of(
            new Add(new Mul(new Num(1), x), new Num(0)),
            new Mul(y, new Add(new Num(2), new Num(-2))),
            new Neg(new Neg(new Mul(x, new Num(3)))),
            new Mul(new Add(new Num(2), new Num(3)), new Neg(new Num(4))));
    Map<String, Integer> env = Map.of("x", 5, "y", 7);
    for (Expr e : expressions) {
        Expr simple = Calc.simplify(e);
        IO.println("%-18s simplifies to %-9s value %d".formatted(Calc.text(e), Calc.text(simple), Calc.eval(simple, env)));
    }
}

classic/StatusResponse.java · status/classic/StatusResponse.java

/**
 * The classic shape of a payment gateway's answer: one class for every outcome, a status string, and fields that only
 * some statuses fill in. Nothing stops a PENDING response with a reference, or a PAID one without.
 */
final class StatusResponse {
    final String status;    // "PAID", "DECLINED" or "PENDING"
    final String reference; // set only when PAID
    final long paise;       // set only when PAID
    final String reason;    // set only when DECLINED

    StatusResponse(String status, String reference, long paise, String reason) {
        this.status = status;
        this.reference = reference;
        this.paise = paise;
        this.reason = reason;
    }
}

classic/ClassicReceipts.java · status/classic/ClassicReceipts.java

/** A receipt for each answer. The code compiles, and the third answer gets a receipt it should never have had. */
public class ClassicReceipts {
    static String receipt(StatusResponse r) {
        if (r.status.equals("DECLINED")) return "declined: " + r.reason;
        return "receipt " + r.reference + " for Rs " + r.paise / 100;
    }

    public static void main(String[] args) {
        StatusResponse[] answers = {
            new StatusResponse("PAID", "4257120938", 1_250_00, null),
            new StatusResponse("DECLINED", null, 0, "insufficient funds"),
            new StatusResponse("PENDING", null, 0, null),
        };
        for (StatusResponse r : answers) System.out.println(receipt(r));
    }
}

status/PaymentStatus.java

/**
 * The same answers as data: one record per outcome, each with exactly the data that outcome has. A Paid without a
 * reference, or with an amount of zero or less, cannot be built: the compact constructor refuses it.
 */
sealed interface PaymentStatus {}

record Paid(String reference, long paise) implements PaymentStatus {
    Paid {
        if (reference == null || reference.isBlank()) throw new IllegalArgumentException("a paid status needs a reference");
        if (paise <= 0) throw new IllegalArgumentException("a paid amount must be positive, not " + paise);
    }
}

record Declined(String reason) implements PaymentStatus {}

record Pending(int minutes) implements PaymentStatus {}

status/Receipts.java

/** One message per status, chosen by record patterns and guards, in a switch without a default. */
public class Receipts {
    /** Receipts from this amount on are also sent by email (a rule of this example shop): Rs 2,00,000.00 in paise. */
    static final long EMAIL_FROM = 2_00_000_00;

    static String message(PaymentStatus status) {
        return switch (status) {
            case Paid(String reference, long paise) when paise >= EMAIL_FROM -> "receipt " + reference + " for " + rupees(paise) + ", also sent by email";
            case Paid(String reference, long paise) -> "receipt " + reference + " for " + rupees(paise);
            case Declined(String reason) -> "declined: " + reason;
            case Pending(int minutes) when minutes >= 30 -> "pending for " + minutes + " minutes: ask the bank, no receipt yet";
            case Pending(int minutes) -> "pending for " + minutes + " minutes: check again soon";
        };
    }

    static String rupees(long paise) {
        return "Rs %d.%02d".formatted(paise / 100, paise % 100);
    }

    public static void main(String[] args) {
        PaymentStatus[] answers = {
            new Paid("4257120938", 1_250_00), new Paid("4257120977", 2_40_000_00),
            new Declined("insufficient funds"), new Pending(4), new Pending(45),
        };
        for (PaymentStatus s : answers) System.out.println(message(s));
        try {
            new Paid(" ", 500_00);
        } catch (IllegalArgumentException e) {
            System.out.println("refused at the boundary: " + e.getMessage());
        }
    }
}

oo/Expr.java · change/oo/Expr.java

import java.util.Map;

/** The same language written the classic way: every record carries its own eval and text. */
interface Expr {
    int eval(Map<String, Integer> env);
    String text();
}

record Num(int value) implements Expr {
    public int eval(Map<String, Integer> env) { return value; }
    public String text() { return Integer.toString(value); }
}

record Var(String name) implements Expr {
    public int eval(Map<String, Integer> env) { return env.get(name); }
    public String text() { return name; }
}

record Add(Expr left, Expr right) implements Expr {
    public int eval(Map<String, Integer> env) { return left.eval(env) + right.eval(env); }
    public String text() { return "(" + left.text() + " + " + right.text() + ")"; }
}

record Mul(Expr left, Expr right) implements Expr {
    public int eval(Map<String, Integer> env) { return left.eval(env) * right.eval(env); }
    public String text() { return "(" + left.text() + " * " + right.text() + ")"; }
}

record Neg(Expr operand) implements Expr {
    public int eval(Map<String, Integer> env) { return -operand.eval(env); }
    public String text() { return "(-" + operand.text() + ")"; }
}

oo/Div.java · change/oo/Div.java

import java.util.Map;

/** A new type: one more record with its own methods. Nothing else has to change. */
record Div(Expr left, Expr right) implements Expr {
    public int eval(Map<String, Integer> env) { return left.eval(env) / right.eval(env); }
    public String text() { return "(" + left.text() + " / " + right.text() + ")"; }
}

oo-more/Expr.java · change/oo-more/Expr.java

import java.util.Map;

/** The same language with a third operation, size, declared in the interface. */
interface Expr {
    int eval(Map<String, Integer> env);
    String text();
    int size();
}

record Num(int value) implements Expr {
    public int eval(Map<String, Integer> env) { return value; }
    public String text() { return Integer.toString(value); }
}

record Var(String name) implements Expr {
    public int eval(Map<String, Integer> env) { return env.get(name); }
    public String text() { return name; }
}

record Add(Expr left, Expr right) implements Expr {
    public int eval(Map<String, Integer> env) { return left.eval(env) + right.eval(env); }
    public String text() { return "(" + left.text() + " + " + right.text() + ")"; }
}

record Mul(Expr left, Expr right) implements Expr {
    public int eval(Map<String, Integer> env) { return left.eval(env) * right.eval(env); }
    public String text() { return "(" + left.text() + " * " + right.text() + ")"; }
}

record Neg(Expr operand) implements Expr {
    public int eval(Map<String, Integer> env) { return -operand.eval(env); }
    public String text() { return "(-" + operand.text() + ")"; }
}

dop/Size.java · change/dop/Size.java

/** A new operation: the number of nodes in an expression. Nothing else has to change. */
final class Size {
    private Size() {}

    static int of(Expr e) {
        return switch (e) {
            case Num _, Var _ -> 1;
            case Add(Expr left, Expr right) -> 1 + of(left) + of(right);
            case Mul(Expr left, Expr right) -> 1 + of(left) + of(right);
            case Neg(Expr operand) -> 1 + of(operand);
        };
    }
}

dop/Expr.java · change/dop/Expr.java

/** The same language with a sixth record, Div. */
sealed interface Expr {}

record Num(int value) implements Expr {}
record Var(String name) implements Expr {}
record Add(Expr left, Expr right) implements Expr {}
record Mul(Expr left, Expr right) implements Expr {}
record Neg(Expr operand) implements Expr {}
record Div(Expr left, Expr right) implements Expr {}

printer/Printer.java

/** Your turn: print an expression with only the brackets that precedence needs. */
final class Printer {
    private Printer() {}

    /** Neg binds most tightly, then Mul, then Add (the rules are in the lesson). */
    static String show(Expr e) {
        return ""; // replace this line with one switch over the five records
    }
}

printer/Checks.java

/** Sample checks for Printer.show: javac -d out expr/Expr.java printer/*.java, then java -cp out Checks */
public class Checks {
    private static int passed;
    private static int total;

    public static void main(String[] args) {
        var x = new Var("x");
        check("7", new Num(7));
        check("x + 2 * 3", new Add(x, new Mul(new Num(2), new Num(3))));
        check("(x + 2) * 3", new Mul(new Add(x, new Num(2)), new Num(3)));
        check("-(x + 2)", new Neg(new Add(x, new Num(2))));
        check("-x * 3", new Mul(new Neg(x), new Num(3)));
        check("-(-3)", new Neg(new Num(-3)));
        System.out.println(passed + " of " + total + " checks passed");
    }

    private static void check(String expected, Expr e) {
        total++;
        String got = Printer.show(e);
        if (got.equals(expected)) passed++;
        else System.out.println("expected \"" + expected + "\" but got \"" + got + "\"");
    }
}