After many months of hard work, the Scala Team is proud to release the first beta of the much-awaited new Scala 2.8! Scala 2.8.0 Beta 1 is now available from our Download Page [1]. It includes a huge number of bug fixes with respect to 2.7.7, and many new features. This beta is the foundation for the release of the upcoming final version of 2.8.0, expected in a few months. Read below to find out what is new!

 

The Scala 2.8.0 Beta distribution

What is new?

The new Scala 2.8 codebase includes the following new fixes and features:

• Redesigned collection library
  The collection library has undergone a complete overhaul for Scala 2.8, offering a more coherent and efficient design, while maintaining virtually complete compatibility with existing sources. Detailed information at: http://www.scala-lang.org/sid/3
  
  [2]
• New array implementation, manifests for polymorphic arrays
  Handling of arrays has been simplified and optimized in Scala 2.8. The previous compiler magic has been replaced by a more systematic and predictable implementation in terms of implicit conversions. Full details at: http://www.scala-lang.org/sid/7
  
  [3]
• Type specialization
  Scala 2.8 adds specialized type parameters, which enable the compiler to generate transparently multiple versions of a given definition, and to use the most specific version whenever the static type information at a call site allows it. Details at: http://www.scala-lang.org/sid/9 [4]

• Named and default arguments
  Named arguments improve the readability of method calls with many arguments. Default arguments reduce code duplication, and enable "copy" methods for case classes, useful to generate quickly modified copies of case classes. A complete description at: http://www.scala-lang.org/sid/1 [5]

• Package objects
  Packages can now contain besides classes and objects also methods, fields or type aliases. These are added to a package by declaring a package object. Package objects are still work in progress; more capabilities might come for 2.8 final or a release soon afterwards.

• Beefed up Scala Swing libraries, better documentation
  Components publish key events, input events can be consumed, refactored window subhierarchy, additional demos, Swing listeners are installed lazily, more complete component caching, minor refactorings, bugfixes, more Scaladocs. Design document at: http://www.scala-lang.org/sid/8 [6]

• Revamped REPL
  Many bugfixes. Tab-completion for all packages on the classpath, as well as object and instance methods and fields, including type aliases and package objects. Searchable history, integrated shell access, and a power mode which offers direct access to compiler internals.

• Implicits changes
  We have refined the implicit resolution process so that resolution is now able to determine type variables.

• Improved equality
  Equality across numeric types is to be consistent across all the primitives types, while also adhering to the equals/hashCode contract. Numeric comparisons will have the same results as they would between Java primitives. This is currently still being completed.

• Packrat parser combinators
  With support for packrat parsing, parser combinators are now able to handle left-recursive grammars and will show improved performance for ambiguous productions.

• Improved XML library
  Many bugfixes.

• Type constructor inference
  Type inference has been extended to deal with type constructors, so that, in certain cases, you can omit type parameter lists that contain higher-kinded types (aka type constructors, e.g., List).

• Improved Annotations
  Scala 2.8 adds support for nested java annotations. For annotations on fields, it is now possible to specify which synthetic members (getter / setter) will have the annotation. Documentation about Scala annotations can be found at: http://www.scala-lang.org/sid/5 [7]

• Enhanced actors
  New Reactors provide more lightweight, purely event-based actors with optional, implicit sender identification. Support for actors with daemon-style semantics was added. Actors can be configured to use the efficient JSR166y fork/join pool, resulting in significant performance improvements on 1.6 JVMs. Schedulers are now pluggable and easier to customize.

• Support for continuations
  Continuations are supported by a compiler plugin. This plugin is not included in this first beta, but will be added in subsequent releases.
   

Internal improvements

• New presentation compiler
  This new infrastructure, within the Scala compiler, enables IDEs to hook into the compiler to find efficiently information about the structure of the program under editing. This new code offers a better platform for the development of IDE plugins.

• New build manager
  The new feature used by for example Eclipse to detect intelligently changes in the files and compile only necessary Scala sources, instead of performing clean build on whole projects. This technique enables to significantly reduce the compilation time on bigger projects.

• Speed improvements
  The compiler now runs as optimised code. In addition, a number of improvements and fine-tunings have further improved the compiler speed up to 50%.
   

Bug fixes

• Scala 2.8 includes a huge number of bug fixes; the main ones are listed at: http://www.scala-lang.org/node/299
  
  [8]

Additional tools

• Scaladoc 2
  A new look-and-feel, automatic comments expansion and wiki-like syntax, as well as compile-time error checking. Read more about changes on the Scaladoc 2 mini-site [9].

• Sbaz 2
  Sbaz includes many bug fixes and enhancements. It now gives better feedback to the user during lengthy downloads and while diagnosing dependency audits, which in turn have been re-factored and enhanced. Sbaz should work properly on Windows using either cmd or cygwin, and is now capable of reliably updating itself. Support for pack200 has been added, in some cases reducing file sizes up to 70%.

• Scalap
  A new Scalap, contributed by the community, is included. The new Scalap is aware of package objects and can decompile them by using <package_name>.package

• Scala IDE for Eclipse
  The IDE has been extensively reworked with much functionality moved into the Scala compiler where it can be better maintained and reused by non-Eclipse IDEs and other tools. The integration with Eclipse's JDT has been deepened, and much previously Scala-specific behaviour and functionality is now provided directly by the JDT leading to across the board improvements.
  
  During the beta preview period, the Scala IDE for Eclipse will be updated more frequently with respect to the main Scala beta releases. You can follow its development by using the following update site:
  

  http://www.scala-lang.org/scala-eclipse-plugin-beta-preview

  Please note that you must use this address as an update site within Eclipse as described on this page [10], it cannot be visited using your internet browser.
   

Acknowledgments and Thanks

Many members of the Scala community have helped us by fixing or reporting bugs, contributing new code and tools (including some of those listed above), and addressing user questions on the mailing lists: their contributions help shaping the future of Scala day by day.

• We would like to thank:
  Paul Phillips, Miles Sabin, Ilya Sergey, Caoyuan Deng, James Matlik, Frank Teubler, Kevin Wright, Manohar Jonnalagedda, Pedro Furlanetto, Johannes Rudolph, Jason Zaugg, Seth Tisue, Ismael Juma, Mark Harrah, Miguel Garcia, Colin Howe, Mirko Stocker, Spiros Tzavellas, Matt Russell, David Taylor, and all the other frequent contributors to our mailing lists, too many to list here. Thank you all!

 

The Scala Team at EPFL

Martin Odersky, Lukas Rytz, Hubert Plociniczak, Iulian Dragos, Gilles Dubochet, Philipp Haller, Aleksandar Prokopec, Antonio Cunei, Tiark Rompf, Eugene Zouev, Donna Malayeri, Phil Bagwell, Adriaan Moors, Ingo Maier.