Scala's "clean up" of type erasure

Question

I have just begun investigating Scala and found the following perplexing quote in the Wikipedia page on Scala:

[Scala] cleans up [...] poor design decisions in Java (e.g. type erasure...

I thought type erasure was a limitation imposed by the Java Virtual Machine, so given that the JVM executes Scala code, how has this been "cleaned up"?

I do appreciate that the designer of Scala also contributed to the JVM, so I am curious to understand if he / the Scala team has augmented the Scala compiler to carry rich run-time type information and thus 'clean up' type erasure. Is this the case?

Thanks in advance for any insight you can provide.

Answer 1

Scala unfortunately still has to deal with type erasure at runtime in the JVM. However, a couple of things have been cleaned up with respect to generics:

• Type parameters are non-optional (no List, only List<String>/List[String])
• Language support for co-/contravariance

Further, to deal with the limitations of the JVM TypeTags (in 2.9 Manifests) can be used to store type information that would otherwise be lost at runtime. For example:

import scala.reflect.runtime.universe._

def foo[T : TypeTag](x: List[T]) = {
  println(implicitly[TypeTag[T]].tpe)
}

This prints the type of the elements of the list. Something which would be irrecoverably lost, if - for example - you pass an empty list:

foo(List.empty[String])
// not distinguishable without TypeTags from
foo(List.empty[Int])

Answer 2

Well, the quote says “cleans up”, not “eliminates”. Type erasure is still there and it can bite you.

Scala has Manifests. Manifest is an object containing information about your actual type. Here is a nice answer about Manifests.