Sum types are amazing! Once I got introduced to them in Rust, it was hard to go back to languages like Java where the enum type is pitiful in comparison.
Java literally has algebraic data types, see sealed classes/interfaces and records.
Not familiar with Java, but C# has sealed classes as well. They are not the real deal. You can fake your way around to achieve something resembling sum types, but the deep language integration like in Rust is simply unattainable. For example, ADT and pattern matching go hand in hand, so you want syntax-level, first class and powerful support for structural pattern matching as well. Not sure about Java, but last I used it C# had only relatively basic support.
Java actually does have pattern matching like this:
int eval(Expr e) {
return switch (e) {
case ConstantExpr(var i) -> i;
case PlusExpr(var a, var b) -> eval(a) + eval(b);
case TimesExpr(var a, var b) -> eval(a) \* eval(b);
case NegExpr(var e) -> -eval(e);
// no default needed, Expr is sealed
}
}
But it only got that recently.And further improvements are expected.
Wishing that eco system the best then! ADTs and pattern matching are the best thing since sliced bread.
Sometimes I wonder: will they become table stakes in the future, or will we wake up to their (currently unknown) downsides in a decade or two? Think of how exceptions are now considered a poor pattern, compared to errors as values.
Do you like doing complex joins with sqlc?
This is such a small fraction of queries on my projects that I don't really pay much attention to it to be honest.
Thanks for mentioning templ, looks interesting. Templates are one of the fields where go has some space for improvements
The stack I settled on:
Postgres + sqlc
templ (kindah jsx for go) + htmx
Barely have to write any js/ts now