I'm really surprised to see Java ranked as less-verbose than OCaml.
Here's an equivalent code sample in Java 17 vs OCaml:
Java:
abstract sealed class Expr permits Value, Add, Subtract, Multiply, Divide {
abstract long eval();
}
record Value(long value) extends Expr {
@Override
long eval() { return value; }
}
record Add(Expr left, Expr right) {
@Override
long eval() { return left.eval() + right.eval(); }
}
record Subtract(Expr left, Expr right) {
@Override
long eval() { return left.eval() - right.eval(); }
}
record Multiply(Expr left, Expr right) {
@Override
long eval() { return left.eval() * right.eval(); }
}
record Divide(Expr left, Expr right) {
@Override
long eval() { return left.eval() / right.eval(); }
}
OCaml:
type expr =
| Value of int
| Add of expr * expr
| Subtract of expr * expr
| Multiply of expr * expr
| Divide of expr * expr
let rec eval = function
| Value value -> value
| Add (left, right) -> (eval left) + (eval right)
| Subtract (left, right) -> (eval left) - (eval right)
| Multiply (left, right) -> (eval left) * (eval right)
| Divide (left, right) -> (eval left) / (eval right)
....Java has so much more syntactical overhead than OCaml, and that's even with recent Java and being pretty aggressive about using boiler-plate reducing sugars like Records. And F# has even less, since it doesn't require you to use different operators for numerics or do as much manual casting between strings/numerics
Winning ugly beats losing pretty. And Jessie Bates is that man.