97. Simplifying expressions via record patterns
Java records can help us a lot to simplify snippets of code meant to handle/evaluate different expressions (mathematical, statistical, string-based, Abstract Syntax Tree (AST), and so on). Typically, evaluating such expressions implies a lot of conditions and checks that can be implemented via if and/or switch statements.For example, let’s consider the following records meant to shape string-based expressions that can be concatenated:
interface Str {}
record Literal(String text) implements Str {}
record Variable(String name) implements Str {}
record Concat(Str first, Str second) implements Str {}
Some parts of the string expression are literals (Literal) while others are provided as variables (Variable). For brevity, we can evaluate these expressions only via the concatenation operation (Concat), but feel free to add more operations.During the evaluation, we have an intermediary step for simplifying the expression by removing/replacing irrelevant parts. For example, we can consider that the terms of the expression that are empty strings can be safely removed from the concatenation process. In other words, a string expression as t + ” ” can be simplified as t, since the second term of our expression is a blank string.The code meant to perform this kind of simplification can rely on type patterns and instanceof as follows:
public static Str shortener(Str str) {
if (str instanceof Concat s) {
if (s.first() instanceof Variable first
&& s.second() instanceof Literal second
&& second.text().isBlank()) {
return first;
} else if (s.first() instanceof Literal first
&& s.second() instanceof Variable second
&& first.text().isBlank()) {
return second;
}
}
return str;
}
This code will become quite verbose if we continue to add more rules for simplifying the given str. Fortunately, we can increase the readability of this code by using record patterns and switch. This way, the code becomes more compact and expressive. Check this out:
public static Str shortener(Str str) {
return switch (str) {
case Concat(Variable(var name), Literal(var text))
when text.isBlank() -> new Variable(name);
case Concat(Literal(var text), Variable(var name))
when text.isBlank() -> new Variable(name);
default -> str;
};
}
How cool is this?