Styjun

I am trying to understand how we can overcome type erasure in scala using ClassTag and TypeTag. I wrote the following examples which are generic functions that try to filter out List[TNode] where TNode is equal to TMatch. However, I expect in recognizeUsingTypeTag, the function shall not call extractUsingClassTag is the generic type of list is equal to TMatch (or the message gets printed), but my assumption is apparently wrong. Thank you.

object Extractor 
 import scala.reflect.ClassTag

 def extractFail[TNode, TMatch](list: List[TNode]) = list.filter 
 case _: TMatch => true
 case _ => false
 .map(x => x.asInstanceOf[TMatch])

 def extractUsingClassTag[TNode, TMatch](list: List[TNode])(implicit tag1: ClassTag[TNode], tag2: ClassTag[TMatch]) = list.filter 
 case _: TMatch => true
 case _ => false
 .map(x => x.asInstanceOf[TMatch])

 import scala.reflect.runtime.universe._

 def recognizeUsingTypeTag[TNode, TMatch](list: List[TNode])(implicit tag1: TypeTag[TNode], tag2: TypeTag[TMatch], tag3: ClassTag[TNode], tag4: ClassTag[TMatch]) = list match 
 case _ if typeOf[TNode] =:= typeOf[TMatch] => 
 //
 // Why this does not get printed for List[String]
 //
 println("This should get printed when called for homogeneous")
 list.asInstanceOf[List[TMatch]]
 
 case _ => extractUsingClassTag[TNode, TMatch](list)
 


val homogeneous: List[String] = List("Hello", "World!")
val heterogeneous: List[Any] = List("Hello", "World!", 123, false)

println("extractFail")
println(Extractor.extractFail[Any, String](homogeneous))
println(Extractor.extractFail[Any, String](heterogeneous) + "n")

println("extractUsingClassTag")
println(Extractor.extractUsingClassTag[Any, String](homogeneous))
println(Extractor.extractUsingClassTag[Any, String](heterogeneous) + "n")

println("recognizeUsingTypeTag")
println(Extractor.recognizeUsingTypeTag[Any, String](homogeneous))
println(Extractor.recognizeUsingTypeTag[Any, String](heterogeneous) + "n")

Console:

extractFail
List(Hello, World!)
List(Hello, World!, 123, false)

extractUsingClassTag
List(Hello, World!)
List(Hello, World!)

recognizeUsingTypeTag
List(Hello, World!)
List(Hello, World!)

Why this does not get printed for List[String]

Because you specified explicit type parameters: [Any, String], so case _ if typeOf[TNode] =:= typeOf[TMatch] compares typeOf[Any] =:= typeOf[String].

Since you do need to specify String for TMatch, but want TNode to be inferred, the usual way to do it is splitting type parameters into two lists by creating an intermediate class:

// in Extractor
class RecognizeUsingTypeTag[TMatch : TypeTag : ClassTag] 
 def apply[TNode : TypeTag : ClassTag](list: List[TNode]) = list match 
 case _ if typeOf[TNode] =:= typeOf[TMatch] => 
 //
 // Why this does not get printed for List[String]
 //
 println("This should get printed when called for homogeneous")
 list.asInstanceOf[List[TMatch]]
 
 case _ => extractUsingClassTag[TNode, TMatch](list)
 


def recognizeUsingTypeTag[TMatch : TypeTag : ClassTag] = new RecognizeUsingTypeTag[TMatch]


println(Extractor.recognizeUsingTypeTag[String].apply(homogeneous)) // inferred as apply[String]
println(Extractor.recognizeUsingTypeTag[String].apply(heterogeneous) + "n") // inferred as apply[Any]

When you have implicit parameters like that and don't need their names, it's preferred to use context bounds: T : TypeTag : ClassTag adds two implicit parameters of types TypeTag[T] and ClassTag[T].