

Scala 2.11.2 is now available - lelf
http://scala-lang.org/news/2.11.2

======
clhodapp
One nice thing that this release does that isn't explicitly mentioned in the
release notes is fix matches on instances of tagged types. Previously, the
pattern match desugarer assumed that all instances of the tagged type were
equal, which meant that the first case where one was used would always match.

------
virtualwhys
Heh, Scala point release, will last about another 10 minutes on HN front page
O_o

Were it Haskell related, well, could be up on HN for days ;-)

Maybe Dotty will bring some excitement back to Scala, these days it's just
bashed upon endlessly, which is unfortunate. Personally _I love Scala_ , warts
and all, it's a wonderful language that often draws criticism without
admitting any of its myriad strengths.

~~~
tormeh
The one thing I would like is for all functions to be pure by default and we
could have something like "impure def" for functions with side-effects and
functions that take mutable objects as arguments. It's basically my only
complaint about the core language. Well, I would also like iota and defer from
Go, but that's minor.

~~~
dpratt
Enforcing pureness on the function might be difficult w.r.t. things like IO,
due to Java interop, and frankly that's one of the strengths of the platform.

Inferring loose immutability constraints on a function would be interesting.
You could implement it in the compiler, perhaps something like an annotation
on a method that declares all inputs must consist of only final/immutable
values, enforced all the way down the chain.

This is more of a JVM gripe, but as long as we're talking about Go, I'd _love_
to see actual VM-level coroutine support. It'd make async code in Scala a lot
easier to both author and debug.

~~~
tormeh
Well, you could just assume that all non-Scala code is impure.

Actually, thinking about it, why not just make it illegal to modify arguments,
full stop? It's perhaps the worst software practice I can think of.

I think Oracle is going to wait a long time until they add that to Java, and
it's not going into the JVM before it's going into Java, unfortunately. Well,
there is a limited number of instructions in the JVM, so using them on things
that are unproven might be a very bad idea.

