Ich hasse es, wenn ich geschachtelte switch-Blöcke sehe. Es ist einfach unübersichtlich, und während man Fälle zusammenfassen kann, wo einem der zweite, „innere“ Wert egal ist, geht das für den ersten, „äußeren“ Wert nicht.
Nehmen wir als Anwendungsfall einmal ein boolesches TriState-Enum, das auch „und“- und „oder“-Operationen unterstützt. Eine mögliche Implementierung könnte so aussehen:
public enum TriState {
TRUE, FALSE, UNKNOWN;
private static TriState and(TriState a, TriState b) {
switch(a) {
case FALSE: return FALSE;
case TRUE: return b;
case UNKNOWN: switch(b) {
case FALSE: return FALSE;
default: return UNKNOWN;
}
}
throw new AssertionError();
}
private static TriState or(TriState a, TriState b) {
switch(a) {
case TRUE: return TRUE;
case FALSE: return b;
case UNKNOWN: switch(b) {
case TRUE: return TRUE;
default: return UNKNOWN;
}
}
throw new AssertionError();
}
}
Man kann sich leicht vorstellen, wie bei mehr Werten die switches schnell unübersichtlich werden. Hier ein Beispiel, wie es mit DSL aussehen könnte:
public enum TriState {TRUE, FALSE, UNKNOWN;
private static TriState and(TriState a, TriState b) {
return switch2(a, b,
case2(TRUE, TRUE, () -> TRUE),
case2(FALSE, any(), () -> FALSE),
case2(any(), FALSE, () -> FALSE),
default2(() -> UNKNOWN)
);
}
private static TriState or(TriState a, TriState b) {
return switch2(a, b,
case2(FALSE, FALSE, () -> FALSE),
case2(TRUE, any(), () -> TRUE),
case2(any(), TRUE, () -> TRUE),
default2(() -> UNKNOWN)
);
}
}
Ich habe mich entschlossen, die „Leerstellen“ über einen speziellen Wert any() zu kennzeichnen. Wenn beide Werte egal sind, habe ich analog zum normalen switch als Synonym auch die Methode default2 bereitgestellt. Ich hoffe, dass das die Bedienung intuitiver macht. Hier die Implementierung des DSLs:
import java.util.Optional;
import java.util.function.BiFunction;
import java.util.function.Supplier;
public final class Switch {
private Switch(){ /*do not instantiate*/ }
enum Any {any}
public static Any any() {
return Any.any;
}
@SafeVarargs
public static <A,B,R> R switch2(A a, B b, BiFunction<A, B, Optional<R>>... cases) {
return Arrays.stream(cases)
.map(biFunction -> biFunction.apply(a,b))
.flatMap(opt -> opt.map(Stream::of).orElseGet(Stream::empty))
.findFirst()
.orElseThrow(() -> new RuntimeException("no match found"));
}
public static <A,B,R> BiFunction<A, B, Optional<R>> case2(A a, B b, Supplier<R> result) {
return (_a, _b) -> a.equals(_a) && b.equals(_b) ? Optional.of(result.get()) : Optional.empty();
}
public static <A,B,R> BiFunction<A, B, Optional<R>> case2(A a, Any any, Supplier<R> result) {
return (_a, _b) -> a.equals(_a) ? Optional.of(result.get()) : Optional.empty();
}
public static <A,B,R> BiFunction<A, B, Optional<R>> case2(Any any, B b, Supplier<R> result) {
return (_a, _b) -> b.equals(_b) ? Optional.of(result.get()) : Optional.empty();
}
public static <A,B,R> BiFunction<A, B, Optional<R>> case2(Any any1, Any any2, Supplier<R> result) {
return default2(result);
}
public static <A,B,R> BiFunction<A, B, Optional<R>> default2(Supplier<R> result) {
return (_a, _b) -> Optional.of(result.get());
}
}
Auch wenn man in anderen Sprachen noch viel „natürlichere“ DSLs schreiben kann, ist es doch immer wieder schön zu sehen, wie „erweiterbar“ Java inzwischen geworden ist, und das ohne größeren Aufwand. Ich glaube aber, dass bei vielen Java-Entwicklern das Bewusstsein fehlt, welche Möglichkeiten sie inzwischen haben. Das ist schade, aber ich hoffe sehr, dass sich das langsam ändert.
