It has indeed come up before. There is some overlap with pattern
switch, and some non-overlap, but it's pretty clear the impact of
pattern switch is much larger.
I would much prefer to finish the discussions on the fundamentals first,
which are actually blocking progress on a much-higher-priority feature.
So let's come back to this later.
I also have reason to believe that, if we do generalized patterns
property, we won't need to do this as a language feature, we can do it
as a library feature. So, let's come back to this later.
On 8/23/2020 11:25 AM, Remi Forax wrote:
There is a feature of Pizza (remember Generic Java ++) we have not discussed
yet,
being able to do a switch on Class.
public sealed interface Numeric<T extends Numeric<T>>
permits Amount, Percentage, Quantity {
private BigDecimal value() {
return switch(this) {
case Amount(value) -> value;
case Percentage(value) -> value;
case Quantity(value) -> value;
};
}
private static <T extends Numeric<T>> T fromValue(Class<T> type, BigDecimal
newValue) {
return type.cast(switch(type) {
case Amount.class -> new Amount(newValue);
case Percentage.class -> new Percentage(newValue);
case Quantity.class -> new Quantity(newValue);
});
}
default T add(T numeric) { return fromValue(getClass(),
value().add(numeric.value())); }
}
with Amount be declared like this
record Amount(BigDecimal value) implements Numeric<Amount> { }
This kind of switch is interesting because it's also one that can be
exhaustive, like the switch on type or the switch on Enum.
In the method fromValue, type is typed as a Class<T> so a Class<? extends
Numeric<...>> and given that Numeric is a sealed class only permitting Amount,
Percentage and Quantity, the only possible Class for a switch(type) are Amount.class,
Percentage.class and Quantity.class.
I'm pretty sure the call fromValue(getClass(), ...) doesn't not compile because the
compiler has no idea that all subtypes of Numeric implements
Numeric<themselves> but you get the idea.
regards,
Rémi
