Type erasure, generics and existential types - scala

Question

I have a List of a parametric type, List[Field[_]], and I want something like this:
sealed trait FieldType[K] { val name: String }
sealed trait StringField extends FieldType[String]
case object publisher extends StringField { val name = "publisher" }
// ...
trait Field[K] {
val field: FieldType[K]
val value: K
}
case class Publisher(value: String) extends Field[String] { val field = publisher }
// ...
def get[K](l: List[Field[_]], key: FieldType[K]) : Option[K] =
l match {
case Nil => None
case (a:Field[K]) :: rest => Some(a.value)
case (a:Field[_]) :: rest => get(rest, key)
}
which doesn't work, because K is erased. I tried typetags, but I must confess I got lost. Any quick way to get what I want?

Answer 1

Yes, you can use type tags to get the compiler to generate the erased type information. According to the Scala documentation there are three ways to optain a tag.
By adding an implicit evidence parameter of type ClassTag, the compiler will generate the missing type information if it cannot find a suitable implicit value. Given the evidence, we can obtain the runtime class and compare it to the runtime class of the value of your Field.
def get[A](l: List[Field[_]])(implicit evidence: ClassTag[A]): Option[A] =
l match {
case Nil => None
case (a: Field[A]) :: rest if evidence.runtimeClass == a.value.getClass =>
Some(a.value)
case a :: rest =>
get[A](rest)
}
However, note that in this example, get[Int] will produce a ClassTag with the runtime class Int whereas value.getClass will return a java.lang.Integer
Given case class Other(value: Int) extends Field[Int], this will yield the following result:
def main(args: Array[String]): Unit = {
println(get[String](Other(4) :: Other(2) :: Publisher("foo") :: Nil)) // Some(foo)
println(get[Integer](Other(4) :: Other(2) :: Publisher("foo") :: Nil)) // Some(4)
println(get[Int](Other(4) :: Other(2) :: Publisher("foo") :: Nil)) // None
}
Note that I removed the parameter key, as it did not serve a purpose. If the key is supposed to be unique, then, instead of checking the type tag, I would suggest matching against the key, thereby not using reflection:
def get[A](l: List[Field[_]], key: FieldType[A]): Option[A] = l match {
case Nil => None
case a :: rest if a.field == key => Some(a.value.asInstanceOf[A])
case a :: rest => get(rest, key)
}
Edit: To address your questions from the comments:
is the asInstanceOf necessary? ... I was under the impression that having to resort to it is sort of bad practice/to be avoided/unsafe. Is that correct?
Since l is of type List[Field[_]], a is of type Field[_], meaning that a.value has the existential type, i.e., the compiler does not know it is of type A. However, because of the relation between a.key and a.value, we know that if a.field is of type FieldType[A], then value is of type A, so this particular type cast is safe (as long as you do not change the code).
You are absolutely correct that having to use a type cast indicates a flaw in the design, so maybe the best solution is to redesign Field, or the list l. Actually, I'd ask myself why you need to put various different types of Field in a list and then extract a certain type of Field later on? Maybe List is the wrong data structure? Would a Map[FieldType[_], List[Field[_]] be a better choice to store your fields? Or a Map[Class[_], List[Field[_]]? Or maybe a custom data structure?
Note that you can get rid of the asInstanceOf in the following way:
def get[A](l: List[Field[_]], key: FieldType[A]): Option[A] = l match {
case Nil => None
case (a: Field[A]) :: rest if a.field == key => Some(a.value)
case a :: rest => get(rest, key)
}
but this does not give you more static safety, because type erasure makes Field[A] match against any generic version of Field. I'd say this variant is worse because it makes the explicit type cast implicit, hence this code is more error prone.
I was trying to use TypeTag[] and typeOf[] instead of ClassTag and runtimeClass, as those where the example I found on the documentation page you linked (and elsewhere). What's the difference? Most of all, I want information regarding the _ in Field[_], so why oh why the ClassTag is on A?!?
There are three type tags that were introduced as a replacement for Manifest:
TypeTag
WeakTypeTag
ClassTag
From the ScalaDoc:
ClassTags are a weaker special case of scala.reflect.api.TypeTags#TypeTags, in that they wrap only the runtime class of a given type, whereas a TypeTag contains all static type information.
While you could probably also solve the problem using TypeTag, I figured that it suffices to compare the runtime class.
The problem is that the existential type can really be any superclass of A, because the list l can contain all kinds of Fields. In the example I gave, we have a list of Field[Int] :: Field[Int] :: Field[String] :: Field[Int], hence the existential type in this case must be Any, the least common supertype of Int and String. In other words: You benefit nothing from deriving the existential type of l: List[Field[_]].
However, what you actually want to do is find the first element in the list whose value is of type A. Because A is erased, the only way to obtain information about its runtime type is by passing the information as an additional argument, e.g., using the implicit ClassTag evidence. Now all that remains is finding out which element has a value of the corresponding type, hence a.value.getClass == evidence.runtimeClass.