scala typetag java,Scala中TypeTags和Manifests的用法

Scala运行在JVM上，在JVM上有一种机制叫做类型擦除(type eraser)。类型擦除是说：在语言的编译阶段程序中所携带的泛型信息都会被擦除，最终生成的class文件中是不包含类型信息的。所以scala 2.8中引入了Manifests类来解决构建Array时遇到的一些问题。然而引入的Manifests并不完美，对于路径依赖类型，它拿到的信息是不精确的。所以后续引入了TypeTags。

展示一下各自的用法。看一个例子，利用manifest获取类型信息。

scala> class A[T]

scala> manifest[List[A[Int]]]

res1: Manifest[List[A[Int]]] = scala.collection.immutable.List[A[Int]]

manifest定义在Predef中，直接使用即可。与manifest功能类似的一个方法是classManifest，

scala> classManifest[List[A[Int]]]

warning: there was one deprecation warning; re-run with -deprecation for details

res2: ClassManifest[List[A[Int]]] = scala.collection.immutable.List[A[Int]]

两个方法都可以拿到相应传入的类型信息，但是观察返回结果：res1的类型是Manifest[List[A[Int]]]，res2的类型是ClassManifest[List[A[Int]]]，两个东西还是有一些区别。接着再看一个例子：

scala> manifest[List[A[_]]]

res3: scala.reflect.Manifest[List[A[_]]] = scala.collection.immutable.List[A[_ <: any>

scala> classManifest[List[A[_]]]

warning: there was one deprecation warning; re-run with -deprecation for details

res4: scala.reflect.ClassTag[List[A[_]]] = scala.collection.immutable.List[A[>]]

在这个例子中manifest会返回所有的类型信息，而classManifest返回了List[A]两层类型，丢失最内部的泛型信息。通过看源码注释对ClassManifest的解释，针对高阶类型它可能不会给出精确的类型信息。所以如果想要得到精确地类型信息使用manifest。

通常Manifest会以隐式参数和上下文绑定的形式使用。

def method[T](arg: T)(implicit m: Manifest[T]) = m //implicit parameter

def method[T: Manifest](arg: T) = m //context bound style

那么，有了Manifest，还要TypeTag干吗？

scala> class Foo { class Bar}

defined class Foo

scala> def m(f: Foo)(b: f.Bar)(implicit t: Manifest[f.Bar]) = t

m: (f: Foo)(b: f.Bar)(implicit t: scala.reflect.Manifest[f.Bar])scala.reflect.Manifest[f.Bar]

scala> val f = new Foo; val b = new f.Bar

f: Foo = Foo@6fe29d36

b: f.Bar = Foo$Bar@6bf7d9d

scala> val ff = new Foo; val bb = new ff.Bar

ff: Foo = Foo@2fdb85b8

bb: ff.Bar = Foo$Bar@75280b93

scala> m(f)(b)

res20: scala.reflect.Manifest[f.Bar] = Foo@6fe29d36.type#Foo$Bar

scala> m(ff)(bb)

res21: scala.reflect.Manifest[ff.Bar] = Foo@2fdb85b8.type#Foo$Bar

scala> res20 == res21 //not expected

res23: Boolean = true

很明显f.Bar和ff.Bar是不相同的类型。所以，scala2.10 引入了TypeTags来解决上述问题，TypeTag可以看成是Manifest的升级版。

def m2(f: Foo)(b: f.Bar)(implicit ev: TypeTag[f.Bar]) = ev

val ev3 = m2(f1)(b1)

val ev4 = m2(f2)(b2)

ev3 == ev4 //false

和TypeTag一同引入的还有ClassTag和WeakTypeTag。ClassTag和ClassManifest一样，也不会返回完整的类型信息。但是它好classManifiest还是有区别的。

scala> classTag[List[_]]

res9: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List

scala> classManifest[List[_]]

warning: there was one deprecation warning; re-run with -deprecation for details

res10: scala.reflect.ClassTag[List[_]] = scala.collection.immutable.List[>]

scala> classTag[List[List[_]]]

res11: scala.reflect.ClassTag[List[List[_]]] = scala.collection.immutable.List

scala> classManifest[List[List[_]]]

warning: there was one deprecation warning; re-run with -deprecation for details

res12: scala.reflect.ClassTag[List[List[_]]] = scala.collection.immutable.List[scala.collection.immutable.List[>]]

classTag只拿到了基础类型信息，没有尝试去拿任何泛型信息，而classManifest拿到了所有已知的类型信息。WeakTypeTag相较TypeTag可以处理带有泛型的参数。看下边的例子：

scala> :pas

// Entering paste mode (ctrl-D to finish)

def weakParamInfo[T](x: T)(implicit tag: WeakTypeTag[T]): Unit = {

val targs = tag.tpe match { case TypeRef(_, _, args) => args }

println(s"type of $x has type arguments $targs")

}

// Exiting paste mode, now interpreting.

weakParamInfo: [T](x: T)(implicit tag: reflect.runtime.universe.WeakTypeTag[T])Unit

scala> def foo[T] = weakParamInfo(List[T]())

foo: [T]=> Unit

scala> foo[Int]

type of List() has type arguments List(T)