Reified generics in Scala on .NET/CLR

Question

Scala (at least on the JVM) uses type erasure for Java compatibility. This feature is widely held to suck. Fixing this would be difficult on the JVM.

In contrast to the

Answer 1

From the answer of this question, you can take that it might be not an advantage at all to have preserved generics in a VM, because it would still dictate what can be represented and what the relations between types are. (For more indepth, go to the original blog by Ola Bini).

Other examples:

• Comparing Impact of Type Erasure in Scala and Java (rather old, 2006) - blog post by Burak Emir, concluding

Erasure seems useful not just for backwards-compatibility, but because complete runtime-type information as promoted by dynamically typed languages comes at a cost. The design of the .NET CLR Generics tackles this cost by code specialization. The above cases should have made clear when it is erasure and when it is the language that is to be blamed for a particular shortcoming.

• Thoughts on erasure - mailing list thread. e.g. David Pollak:

The net-net is that if the JVM had reified generics (no type erasure), it would not be possible to implement Scala's type system... Scala's type system is more complex than Java's and if the JVM had generics based on Java generics, we'd still have problems in Scala. On the other hand, type erasure allows the compiler to implement a complex type system, even if all the type information is not available at runtime.

---

As far as I know Scala's .NET backend is far behind the current JVM implementation, and also doesn't support .NET's reified generics.

---

Scala 2.10 even goes further in the direction of abstracting type information from the actual virtual machine model. Martin Odersky presented the new reflection/reification interaction in a presentation which is for example embedded in this entry (beginning at 42'18").

I believe that you will then be able to use the type-tags (which replace manifests) to overcome the problems with pattern matching and erasure. There is a bit on this mailing list thread, but I don't know to what extent it works or doesn't.

(Pure speculation:) Going for more abstraction might help with backends for platforms which have even less type information than the JVM, e.g. a hypothetical compilation to JavaScript.