Scala 2.10.0-M2 / 2.9.1-1 Final - Changelog

What's new in Scala 2.9.1-1 Final:

March 5th, 2012

· Don't mark mixed-in methods as bridges.
· Add SYNTHETIC flag for BRIDGE methods.
· Update build for publishing to sonatype OSSRH

What's new in Scala 2.10.0-M2:

February 22nd, 2012

· Support for implementing a parallel collection using a concurrent collection. In particular, one should be able to implement a combiner using a concurrent (thread-safe) collection.
· Ctries added to the standard library. Implement parallel ctries using the above mechanism.
· New futures and promises library added to scala.concurrent, joint work with the Akka team.
· Numerous improvements to reification.
· Virtual pattern matcher improvements -- please try compiling your project with -Yvirtpatmat, it will be on by default starting with 2.10.0-M3!
· A significantly faster optimizer.
· Improvements to RedBlack tree.
· Fixes to specialization (AnyRef, interaction of final and @inline -- thank you, Erik Osheim!).

Closed tickets:
· SI-4336 polymorphic expression isn't adapted to the expected type
· SI-4835 scala.collection.immutable.StreamIterator[+A] has O(n) memory consumption
· SI-5066 Predef.readLine(String, Any*) should call Console.readLine(text, args: _*) (Thank you, Szabolcs Berecz!)
· SI-5215 Scalac crashes when I use @elidable for trait (Thank you, Szabolcs Berecz!)
· SI-5224 Cannot reify @serializable class C
· SI-5225 Bad reification of @transient @volatile var x = 2
· SI-5229 Cannot reify objects
· SI-5256 Classloading problems in REPL with Scala reflection
· SI-5269 Cannot reify traits
· SI-5270 Cannot reify self-types
· SI-5271 Cannot reify case classes
· SI-5272 Cannot reify simple pattern match
· SI-5273 Cannot reify unapply-based pattern match
· SI-5274 Cannot reify recursive functions
· SI-5275 Cannot reify constructors with val-parameters
· SI-5276 Cannot reify lazy vals
· SI-5277 Cannot reify implicits
· SI-5279 Cannot reify implicitly imported stuff from java.lang
· SI-5287 Use case methods hide information about the actual method
· SI-5293 Performance: Copying mutable.HashSet (FlatHashTable) 100x slower than java.util.HashSet.
· SI-5334 Cannot reify code that returns an object of a locally defined type
· SI-5335 Cannot reify anonymous classes
· SI-5374 Deserialization of ListBuffer results in a non-mutable structure prone to throwing NoSuchElementException
· SI-5375 Deadlock when parallel collection function throws an exception
· SI-5405 Documentation error in scala.math.BigInt
· SI-5419 Cannot reify 5: @Int
· SI-5423 Mirror doesn't load annotations
· SI-5429 object may override a def causing ClassCastException in unrelated code
· SI-5444 Crash in LambdaLift
· SI-5452 Stack overflow in doTypedApply when manifests meet overloads
· SI-5497 undefined value leads to "no-symbol does not have an owner"
· SI-5500 Strange type error with some AnyRef specializations (but not others)
· SI-5506 cps errors with lists

What's new in Scala 2.9.0.1:

July 26th, 2011

Parallel Collections:
· Every collection may be converted into a corresponding parallel collection with the new `par` method. Parallel collections utilize multicore processors by implementing bulk operations such as `foreach`, `map`, `filter` etc. in parallel. Parallel collections are located in the package `scala.collection.parallel`.
· Depending on the collection in question, `par` may require copying the underlying dataset to create a parallel collection. However, specific collections share their underlying dataset with a parallel collection, making `par` a constant time operation.

· Currently available parallel collections are -
· parallel arrays - scala.collection.parallel.mutable.ParArray
· parallel ranges - scala.collection.parallel.immutable.ParRange
· parallel hash maps - scala.collection.parallel.mutable.ParHashMap
· parallel hash sets - scala.collection.parallel.mutable.ParHashSet
· parallel hash tries - scala.collection.parallel.immutable.{ParHashMap, ParHashSet}
· parallel vectors - scala.collection.parallel.immutable.ParVector

· The method `seq` is used to convert from a parallel collection to a corresponding sequential collection. This method is always efficient (O(1)).

The App Trait:
The App trait is a safer, more powerful alternative to the previous Application trait, which has now been deprecated. The new recommended way to write a top-level application is like this:

· object Echo extends App {
· println("Echo" + (args mkString " "))
· }

· Objects inheriting from the old Application trait were almost as convenient to write, but were not thread-safe and were often not optimized by the VM, since the application’s body was execited as part of of the object’s initialization sequence. Objects inheriting the App trait instead make use of Scala 2.9’s delayed initialization feature to execute the whole body as part of an inherited main method.

· Another new feature of the App scheme is that command line arguments are now accessible via the args value (which is inherited from trait App)
· The DelayedInit Trait

· The DelayedInit trait provides another tool to customize initialization sequences of classes and objects. If a class or object inherits from this trait, all its initialization code is packed in a closure and forwarded as an argument to a method named delayedInit which is defined as an abstract method in trait DelayedInit.

· Implementations of delayedInit have thus full freedom when to execute the initialization code. For instance, Scala’s new App trait stores all initialization sequences in an internal buffer and executes them when the object’s main method is called.

· Note that only initialization code contained in classes and objects is passed to DelayedInit; initialization code contained in traits is not affected.
· Repl Improvements

· Improvements in jline, the repl input handler. More robust cursor handling, bash-style ctrl-R history search, new commands like :imports, :implicits, :keybindings. On platforms with the necessary runtime support, :javap will disassemble any class including repl-defined ones. A long-running repl command can now be interrupted via ctrl-C without terminating the repl session. Improved programmability: the repl classloader exposes repl-defined classes via their given names.
· Scala Runner

· Scala code can now be executed in any of the following ways -
· scala will run the main class, similar to java -jar
· scala will run the main method of that class
· scala will run the script contents as a scala script
· scala will, if the contents are not a script, find a single main method in a top level object and run that. This allows the same file to be used with scalac and to be run directly.
· scala -save will create a jar file with the compiled source, which is then reusable and can be run as scala

Java Interop:
· The @strictfp annotation is now supported.

· Various fixes in JavaConverters and JavaConversions for smoother interoperation.

· Primitive types and their boxed versions are now implicitly converted bidirectionally.

Other features:
· Generalized try-catch-finally -
· try body
· catch handler
· finally cleanup

· Here, body and cleanup can be arbitrary expressions, and handler can be any expression which evaluates to a valid exception handler (which is: PartialFunction[Throwable, T]).

· New packages
· scala.sys and scala.sys.process, which are imported from sbt.Process.

· New methods in collections
· collectFirst, maxBy, minBy, span, inits, tails, permutations, combinations, subsets

· AnyRef specialization
· It’s now possible to specialize on type parameters for subtypes of AnyRef (class Foo[@specialize(AnyRef) T](arr: Array[T]) { … }), which allows for more efficient array indexing and updates.