How do I get around type erasure on Scala? Or, why can't I get the type parameter of my collections?

Question

It's a sad fact of life on Scala that if you instantiate a List[Int], you can verify that your instance is a List, and you can verify that any individual element of it is an Int, but not that it is a List[Int], as can be easily verified:

scala> List(1,2,3) match {
     | case l : List[String] => println("A list of strings?!")
     | case _ => println("Ok")
     | }
warning: there were unchecked warnings; re-run with -unchecked for details
A list of strings?!

The -unchecked option puts the blame squarely on type erasure:

scala>  List(1,2,3) match {
     |  case l : List[String] => println("A list of strings?!")
     |  case _ => println("Ok")
     |  }
<console>:6: warning: non variable type-argument String in type pattern is unchecked since it is eliminated by erasure
        case l : List[String] => println("A list of strings?!")
                 ^
A list of strings?!

Why is that, and how do I get around it?

Answer 1

Scala was defined with Type Erasure because the Java Virtual Machine (JVM), unlike Java, did not get generics. This means that, at run time, only the type exists, not its parameters. In the example, JVM knows it is handling a scala.collection.immutable.List, but not that this list is parameterized with Int.

Fortunately, an obscure, and experimental, feature of Scala let you get around that. It’s the Manifests. A Manifest is class whose instances are objects representing types. Since these instances are objects, you can pass them around, store them, and generally call methods on them. With the support of implicit parameters, it becomes a very powerful tool. Take the following example, for instance:

object Registry {
  import scala.reflect.Manifest

  private var _map= Map.empty[Any,(Manifest[_], Any)] 

  def register[T](name: Any, item: T)(implicit m: Manifest[T]) {
    _map = _map(name) = (m, item)
  }

  def get[T](key:Any)(implicit m : Manifest[T]): Option[T] = {
    val o = _map.get(key)

    o match {
      case Some((om: Manifest[_], s : Any)) =>
        if(om <:< m) Some(s.asInstanceOf[T]) else None
      case _ => None
    }
  }
}

scala> Registry.register("a", List(1,2,3))

scala> Registry.get[List[Int]]("a")
res6: Option[List[Int]] = Some(List(1, 2, 3))

scala> Registry.get[List[String]]("a")
res7: Option[List[String]] = None

When storing an element, we store a "Manifest" of it too. A Manifest is a class whose instances represent Scala types. These objects have more information than JVM does, which enable us to test for the full, parameterized type.

As mentioned, this feature is experimental, and there are cases in which it doesn't work. Still, it can go a long way.

Answer 2

I can't comment yet :/ But what concerns me is that this information (question/answer), especially being phrased like this, really belongs in the Scala documentation.

If someone is going to go all the trouble of posing a question and then answering it himself, when it's as thoughtful, informative, intentional and as internal (to the workings of Scala) as this then that effort should instead be spend on documenting it properly where it belongs.

Does this already exist in Scala documentation anywhere?

Don't get me wrong Daniel - I love your work :P

Answer 3

Scala 2.8 Beta 1 RC4 just made some changes to how type erasure works. I'm not sure if this directly affects your question.