[pharmakom]

The major differences between Java and F# are:

- Discriminated unions and pattern matching

- Global type inference

- Tail call optimisation

- Syntactic sugar for monadic code (computation expressions)

Java is more “FP” than it used to be, but it is still not minimum viable FP

[kaba0]

Java has sum types and is in the process of getting pattern matching (some basic form is already available, but `case Sphere(Point(int x, var y), var r)` already works in preview).

For sum types, the syntax is like this:

  sealed interface Expression permits Add, Mult, Identifier {}
  // possibly later
  record Add(Expression a, Expression b) extends Expression {}
  record Identifier(String name) extends Expression {}

I do like global type inference, but for anything that gets committed I often come to prefer at least Rust’s restriction of top level definitions needing types, as that aligns well with how I would also write Haskell and alia. Java imo made a good decision of only adding optional local inference, anything else would have been too disruptive for Java, given its existing talent pool’s background.

[karmakaze]

Definitely I would not call Java an FP language, even Rust has a flavoring of FP. Besides the monadic constructs not having proper sum types/d.unions is really annoying. Sealed enums are not the same utility.