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

by

This answer uses the Manifest-API, which is deprecated as of Scala 2.10. Please see answers below for more current solutions.

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 class exists, not its type parameters. In the example, JVM knows it is handling a scala.collection.immutable.List, but not that this list is parameterized with Int.

Fortunately, there’s a feature in Scala that lets you get around that. It’s the Manifest. 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.updated(name, m -> item)
  }
  
  def get[T](key:Any)(implicit m : Manifest[T]): Option[T] = {
    map get key flatMap {
      case (om, s) => if (om <:< m) Some(s.asInstanceOf[T]) else 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.

Note, however, that a Manifest is still an evolving feature. As an example of its limitations, it presently doesn’t know anything about variance, and assumes everything is co-variant. I expect it will get more stable and solid once the Scala reflection library, presently under development, gets finished.

More Related Contents:

  1. How to pattern match on generic type in Scala?
  2. Scala double definition (2 methods have the same type erasure)
  3. Cleaner way to update nested structures
  4. Why is Scala’s immutable Set not covariant in its type?
  5. Why “avoid method overloading”?
  6. How can I change column types in Spark SQL’s DataFrame?
  7. Need clarification on Scala literal identifiers (backticks)
  8. Scala how can I count the number of occurrences in a list
  9. What is the difference between def foo = {} and def foo() = {} in Scala?
  10. Case class to map in Scala
  11. Difference between using App trait and main method in scala
  12. Functional programming, Scala map and fold left [closed]
  13. What does => and () => mean in Scala [duplicate]
  14. Load Scala file into interpreter to use functions?
  15. Any reason why scala does not explicitly support dependent types?
  16. Reduce, fold or scan (Left/Right)?
  17. Apache Spark, add an “CASE WHEN … ELSE …” calculated column to an existing DataFrame
  18. How to suppress info and success messages in sbt?
  19. Replace null values in Spark DataFrame
  20. Scala: write string to file in one statement
  21. Scala: pass Seq to var-args functions
  22. Calculate Cosine Similarity Spark Dataframe
  23. Why does Scala support shadow variables? [closed]
  24. What does a single apostrophe mean in Scala? [duplicate]
  25. Treating an SQL ResultSet like a Scala Stream
  26. Queries with streaming sources must be executed with writeStream.start();
  27. Singletons as Synthetic classes in Scala?
  28. Understanding the Aux pattern in Scala Type System
  29. Akka-Stream implementation slower than single threaded implementation
  30. Multiple parameter closure argument type not inferred

Leave a Comment