scala : Match type argument for an object

Question

if i have a class that accepts a Type argument for example Seq[T] , and i've many objects of this class. and i want to split them depending on type Argument T

for example :

val x = List(Seq[Int](1,2,3,4,5,6,7,8,9,0),Seq[String]("a","b","c"))
x.foreach { a => 
  a match{ 
    case _ : Seq[String] => print("String") 
    case _ : Seq[Int] => print("Int")  
   }
 }

the result of this code is StringString. it only matches the class Seq not the Type also , what should i do to force it to match the Type ?

Answer 1

What you're seeing happens due to Type Erasure (http://docs.oracle.com/javase/tutorial/java/generics/erasure.html), some IDEs can warn you for errors like these.

You could have a look at Manifests, for example check out What is a Manifest in Scala and when do you need it?

Edit: like Patryk said, TypeTag replaced Manifest in Scala 2.10, see Scala: What is a TypeTag and how do I use it?

Answer 2

TypeTag Approach

The Java runtime requires generic type param erasure. Scala compiler combats this by 'injecting' type info into methods declared with TypeTag type arg:

def typeAwareMethod[T: TypeTag] (someArg: T) { 
  ... // logic referring to T, the type of varToCheck
}

(alternatively, can use an equivalent, more long-winded implicit param - not shown)

When scala compiles an invocation of a method having (1) type arg [T: TypeTag] and (2) normal arg someArg: T, it collects type param metadata for someArg from the calling context and augments the type arg T with this metadata. T's value plus tag data are externaly type-inferred from calls:

val slimesters = List[Reptile](new Frog(...), new CreatureFromBlackLagoon(...))
typeAwareMethod(slimesters)

Logic Referring to T (within above method) - runtime reflection

import scala.reflection.runtime.universe._ : contents of the universe object of type scala.relection.api.JavaUniverse. NB: subject to evolutionary API change

1. Direct TypeTag comparison: The tag info can be obtained via method typeTag[T], then directly tested/pattern matched for (exact) equality with other type tags:

   val tag: TypeTag[T] = typeTag[T]
   
   if (typeTag[T] == typeTag[List[Reptile]]) ...
   
   typeTag[T] match {
     case typeTag[List[Reptile]] => ...
   }
   

   Limitations: not subtype aware (above won't match List[Frog]); no additional metadata obtainable through TypeTag.

2. Smarter Type-comparison operations:

   Convert to Type via typeOf[T] (or typeTag[T].tpe). Then use the gammut of Type ops, including pattern-matching. NB: in reflection typespace, =:= means type equivalance (analogue of :), <:< means type conformance (analogue of <:)

   val tType: Type = typeOf[T] // or equivalently, typeTag[T].tpe
   
   if (typeOf[T] <:< typeOf[List[Reptile]]) ...  // matches List[Frog]
   
   typeOf[T] match {
     case t if t <:< typeOf[List[Reptile]] => ...
   }
   
   // Running Example:
   def testTypeMatch[T: TypeTag](t: T) = if (typeOf[T] <:< typeOf[Seq[Int]]) "yep!!!"
   
   test(List[Int](1, 2, 3))  // prints yep!!!
   

   Method still needs type param [T: TypeTag] or you'll get the type-erasure view of the world...

3. Introspect on Type metadata

   I lied in 2 ;). For your case, typeOf[T] actually returns TypeRef (a subtype of Type), since you're instantiating a type declared elsewhere. To get at the full metadata, you need to convert Type to TypeRef.

   typeTag[T].tpe match {
     case t: TypeRef => ... // call t.args to access typeArgs (as List[Type])
     case _ => throw IllegalArgumentException("Not a TypeRef")
   }
   

   • instead of t: TypeRef, can extract parts via pattern match on:

       case TypeRef(prefixType, typeSymbol, typeArgsListOfType) =>
     

   • Type has method:

     def typeSymbol: Symbol
     

   • Symbol has methods:

     def fullName: String
     def name: Name
     

   • Name has methods:

     def decoded: String  // the scala name
     def encoded: String  // the java name
     

Solution For Your Case

Solution based on (3):

import scala.reflect.runtime.universe._

def typeArgsOf[T: TypeTag](a: T): List[Type] = typeOf[T] match {
  case TypeRef(_, _, args) => args
  case _ => Nil
}

val a = Seq[Int](1,2,3,4,5,6,7,8,9,0)
val b = Seq[String]("a","b","c")
// mkString & pring for debugging - parsing logic should use args, not strings!
print("[" + (typeArgsOf(a) mkString ",") + "]")
print("[" + (typeArgsOf(b) mkString ",") + "]")

---

Aside: there's an issue with this test case:

val x = List(Seq[Int](1,2,3,4,5,6,7,8,9,0),Seq[String]("a","b","c"))

Type of x is List[Seq[Any]]. Any is the lowest common ancestor of String and Int. In this case there's nothing to introspect, since all types descend from Any , and there's no further type information available. To get stronger typing, separate the two Seqs, either via separate variables or a tuple/pair - but once separated, no higher order common mapping / folding across the two. "Real world" cases shouldn't have this problem.

Answer 3

I would argue it's equally sensible to def the logic with multiple prototypes one per sequence type, than go into those type-erasure workarounds. The 2.10 compiler doesn't warn about type erasure, and at runtime it seems to work well in my case.

Presumably this avoids the problem, producing more intelligible code.