Pattern Matching in Java (17)

interface Node { }

record Number(long number) implements Node { }

record Negate(Node node) implements Node { }

record Absolute(Node node) implements Node { }

record Add(List<Node> summands) implements Node {

	Add(Node... summands) {
		this(List.of(summands));
	}

}

new Add(
	new Number(1),
	new Negate(new Number(2)),
	new Absolute(new Add(
		new Number(3),
		new Negate(new Number(4)))));

interface Node { long evaluate(); }

record Number(long number) implements Node {
	public long evalute() { return number; }
}

record Negate(Node node) implements Node {
	public long evalute() { return -node.evalute(); }
}

static long evaluate(Node node) {
	// ...
}

interface Node { }

record Number(long number) implements Node { }
record Negate(Node node) implements Node { }
record Absolute(Node node) implements Node { }
record Add(List<Node> summands) implements Node { }

static long evaluate(Node node) {
	if (node instanceof Number)
		return ((Number) node).number();
	if (node instanceof Negate)
		return -evaluate(((Negate) node).node());
	if (node instanceof Absolute) {
		long r = evaluate(((Absolute) node).node());
		return r >= 0 ? r : -r;
	}
	if (node instanceof Add)
		return ((Add) node)
			.summands().stream()
			.mapToLong(Nodes::evaluate)
			.sum();
	throw new IllegalStateException();
}

//       |---- pattern -----|
//target |---- test -----| variable
if (node instanceof Number no)
	// ... use `Number no`

static long evaluate(Node node) {
	if (node instanceof Number no)
		return no.number();
	if (node instanceof Negate neg)
		return -evaluate(neg.node());
	if (node instanceof Absolute abs) {
		long result = evaluate(abs.node());
		return result >= 0 ? result : -result;
	}
	if (node instanceof Add add)
		return add
			.summands().stream()
			.mapToLong(Nodes::evaluate)
			.sum();
	throw new IllegalStateException();
}

// makes `node` the target
switch (node) {
//  |- test --| variable
	case Number no -> // ... use `Number no`
	// other cases
}

static long evaluate(Node node) {
	return switch (node) {
		case Number no -> no.number();
		case Negate neg -> -evaluate(neg.node());
		case Absolute abs -> {
			long result = evaluate(abs.node());
			yield result >= 0 ? result : -result;
		}
		case Add add -> add
			.summands().stream()
			.mapToLong(Nodes::evaluate)
			.sum();
		default ->
			throw new IllegalArgumentException();
	};
}

// flashback
record Number(long number) implements Node { }

if (node instanceof Number(long no))
	// ... use `long no`
switch (node) {
	case Number(long no) -> // ... use `long no`
	// other cases
}

static long evaluate(Node node) {
	return switch (node) {
		case Number(long no) -> no;
		case Negate(var n) -> -evaluate(n);
		case Absolute(var n) {
			long result = evaluate(n);
			yield result >= 0 ? result : -result;
		};
		case Add(var summands) -> summands.stream()
			.mapToLong(Nodes::evaluate)
			.sum();
		default ->
			throw new IllegalArgumentException();
	};
}

Node node = // ...
switch (node) {
	case Number(long no && no > 0) ->
		// ... use `long no`, which is positive
	case Number(long no && no < 0) ->
		// ... use `long no`, which is negative
	case Number(long __) ->
		// we know the number is 0
	// other cases
}

static long evaluate(Node node) {
	return switch (node) {
		case Number(long no) -> no;
		case Negate(var n) -> -evaluate(n);
		case Absolute(var n) && evaluate(n) < 0 ->
			-evaluate(n);
		case Absolute(var n) -> evaluate(n);
		case Add(var summands) -> summands.stream()
			.mapToLong(Nodes::evaluate)
			.sum();
		default ->
			throw new IllegalArgumentException();
	};
}

// 👾👾👾: 🤨
sealed interface Node
	permits Number, Negate, Absolute, Add { }
// ⇝ no other type can implement `Node`

static long evaluate(Node node) {
	return switch (node) {
		case Number(long no) -> no;
		case Negate(var n) -> -evaluate(n);
		case Absolute(var n) && evaluate(n) < 0
			-> -evaluate(n);
		case Absolute(var n) -> evaluate(n);
		case Add(var summands) -> summands.stream()
			.mapToLong(Nodes::evaluate)
			.sum();
		// no default branch needed
	};
}