This summary is intended for Scala contributors and maintainers, and assumes a certain familiarity with Scala's internals.

It is for your information only, provided “AS IS” with no warranties and it confers no lefts (or rights).

hi,

just stumbled over http://ochsenreither.posterous.com/whats-new-in-210, and i'm quite excited at the outlook of scala 2.10.

i know `Predef.???` is an old thread, i just wanted to add that SuperCollider has a more verbose but very nice method for this:

notYetImplemented { NotYetImplementedError(nil, this).throw; }

i think this makes much more sense than `???` and also `undefined` (which is confusing with respect to partial functions, sets, maps etc.).

so you'd have

class X {
def aMethod: Int = notYetImplemented
}

best, .h.h.

I've found this funny line next to caseClassCopyMeth, and it makes me
sad.

The point is that the only ValDefs I can produce in the reifier are
the ones with TypeTrees, which will be happily erased by UnTyper. But
if that happens, then a few moments later case TypeTree() in
isRepeatedParamType will crash with NPE, which is a symptom of a
systemic problem - reified types are sometimes erased by subsequent
reflective compilation.

What do I do with that? Is it possible to patch UnTyper so that it
preserves reified types?

Hi Hubert,

I am trying to get value classes working, and stumbled on a problem
this morning. I
was trying to create an array of two Meters, where Meter is a value class.

class Meter(...) extends AnyVal ...
val x: Meter
val arr = Array(x, x + x)

It crashed in superaccessors because a generated manifest contained an
error value (stacktrace appended). The problem was clearly that
superaccessors should not have been run because typer produced an
error. But that error was never reported.

Is there a way to get a symbol if I know its owner and its name?

Positive answer will be very useful for importers (that provide
bijection between universes, e.g. between reflective mirror and
reflective compiler).

Currently importers create a new symbol for every symbol they haven't
seen yet. This means that certain symbols can be created multiple
times - once inside their own universe and once again during an import
from a universe that already has the same symbol.

Hi All,

Not sure you all have seen this but we've been publishing a series of
articles on the performance analysis of the existing 2.9.1 scala
compiler code base. We did not set out to address all performance
concerns of the compiler but to look at the issues one has in measuring
(in our case metering) scala derived class bytecode. There has been a
lot said about complexity but rarely has this actually looked at how
does one make sense of the execution of such bytecode when traceability
back to source and constructs is not as easy as it has been in Java
itself with the mapping being explicit, direct and immediate.