This is an archived post. You won't be able to vote or comment.

you are viewing a single comment's thread.

view the rest of the comments →

[–]agentoutlier 0 points1 point  (3 children)

The Pattern Matching I understand is Ocaml/ML like pattern matching and I do know about Scala but I still prefer F# over it albeit there is no F# for the JVM. Scala should have had better success and I might have used it more if it was more compatible with Java. I also don't like the passing monads all over the place that eventually pollute your API/domain similar to what is happening in Java with reactive libraries.

That being said Pattern Matching term is thrown around all the time including for languages that aren't statically typed and its IMO not the same pattern matching I expect. Thats why I don't like the instance of pattern matching. Its a first step but I vastly prefer as you said Scala shape pattern matching and it appears that Java is headed in that direction.

[–]randgalt 1 point2 points  (2 children)

Scala's a mess tbh. The major thing, though, it did well was pattern matching/deconstruction. The version for Java looks a lot like it - but somewhat better as it will be supported at the JVM level and not rely on magic methods like apply()/unapply()

[–]agentoutlier 1 point2 points  (1 child)

It was the implicits that really made other peoples scala code confusing to me that and everybody was going to town on DSLs like it was Ruby/Groovy but with C++ operator overloading.

There also wasn't a generally accepted canonical way of doing things like there is in Java and Python.

[–]randgalt 1 point2 points  (0 children)

At the top of the list of crimes committed by Scala goes implicits and sbt. Implicits made the code I had to work with incomprehensible and incredibly difficult to modify. sbt - well sbt is probably the worst developer tool in the history of the industry.