What reflection capabilities can we expect from Scala 2.10?

Scala 2.10 brings reflection other than that provided the JVM (or I guess CLR).

What in particular do we have to look forward to, and how will it improve on the platform?

For example, will there be a class that reflects the language's convertibility between fields and accessor methods, s开发者_开发百科o that I can iterate over the properties of an object?

update 2012-07-04:

Daniel SOBRAL (also on SO) details in his blog post "JSON serialization with reflection in Scala! Part 1 - So you want to do reflection?" some of the features coming with reflection:

To recapitulate, Scala 2.10 will come with a Scala reflection library.
That library is used by the compiler itself, but divided into layers through the cake pattern, so different users see different levels of detail, keeping jar sizes adequate to each one's use, and hopefully hiding unwanted detail.

The reflection library also integrates with the upcoming macro facilities, enabling enterprising coders to manipulate code at compile time.

update 2012-06-14. (from Eugene Burmako):
In Scala 2.10.0-M4, we have released the new reflection API that will most likely make it into 2.10.0-final without significant changes.
More details about the API can be found:

• SO answer Get companion object instance with new Scala reflection API
• Scala Reflection SIP, June 2012 by Martin Odersky (SIP, actually "Scala Improvement Process")
• summary and migration route from M3

Extracts:

Universes and mirrors are now separate entities:

• universes host reflection artifacts (trees, symbols, types, etc),
• mirrors abstract loading of those artifacts (e.g. JavaMirror loads stuff using a classloader and annotation unpickler, while GlobalMirror uses internal compiler classreader to achieve the same goal).

Public reflection API is split into scala.reflect.base and scala.reflect.api.

• The former represents a minimalistic snapshot that is exactly enough to build reified trees and types.
• To build, but not to analyze - everything smart (for example, getting a type signature) is implemented in scala.reflect.api.

Both reflection domains have their own universe: scala.reflect.basis and scala.reflect.runtime.universe.

• The former is super lightweight and doesn't involve any classloaders,
• while the latter represents a stripped down compiler.

Initial answer, Sept. 2011:

You can see evolutions of the reflect package in the Scala GitHub repo, with this two very recent commits:

• Changes to Liftcode to use new reflection semantics, where a compiler uses type checking.
• Started work on compiler toolbox that can compile reflect trees at runtime.

(Liftcode being, according to this thread, aims at simplifying "writing code that writes code")

The class scala/reflect/internal/Importers.scala (created yesterday!) is a good example of using those latest reflection feature.

Two links which should be of interest:

• The scala-internals mailing list discussion on the reflection api.
• The nightly build api doc for 2.10-SNAPSHOT.

Personally I am hoping to use this for doing runtime discovery of extensions (i.e. a type that extends a known trait), and generating UI forms and a few other things from those.

With current 2.10M4 you already can iterate over members of a class:

reflect.runtime.universe.typeOf[MyClass].members.filter(!_.isMethod)

The above code lists Symbol objects representing members of a class MyClass which are not methods. There are tons of ways you can fine-tune this.