我对TypeTag所了解的只是它们以某种方式替代了Manifests。互联网上的信息稀缺,无法使我对这个主题有很好的了解。

因此,如果有人共享指向TypeTag上一些有用 Material 的链接(包括示例和流行的用例),我将感到非常高兴。也欢迎提供详细的答案和解释。

最佳答案

TypeTag解决了Scala类型在运行时被擦除的问题(类型擦除)。如果我们想做

class Foo
class Bar extends Foo

def meth[A](xs: List[A]) = xs match {
  case _: List[String] => "list of strings"
  case _: List[Foo] => "list of foos"
}

我们将收到警告:
<console>:23: warning: non-variable type argument String in type pattern List[String]↩
is unchecked since it is eliminated by erasure
         case _: List[String] => "list of strings"
                 ^
<console>:24: warning: non-variable type argument Foo in type pattern List[Foo]↩
is unchecked since it is eliminated by erasure
         case _: List[Foo] => "list of foos"
                 ^

为了解决这个问题,将Manifests引入了Scala。但是它们有一个问题,就是不能表示很多有用的类型,例如路径依赖类型:
scala> class Foo{class Bar}
defined class Foo

scala> def m(f: Foo)(b: f.Bar)(implicit ev: Manifest[f.Bar]) = ev
warning: there were 2 deprecation warnings; re-run with -deprecation for details
m: (f: Foo)(b: f.Bar)(implicit ev: Manifest[f.Bar])Manifest[f.Bar]

scala> val f1 = new Foo;val b1 = new f1.Bar
f1: Foo = Foo@681e731c
b1: f1.Bar = Foo$Bar@271768ab

scala> val f2 = new Foo;val b2 = new f2.Bar
f2: Foo = Foo@3e50039c
b2: f2.Bar = Foo$Bar@771d16b9

scala> val ev1 = m(f1)(b1)
warning: there were 2 deprecation warnings; re-run with -deprecation for details
ev1: Manifest[f1.Bar] = [email protected]#Foo$Bar

scala> val ev2 = m(f2)(b2)
warning: there were 2 deprecation warnings; re-run with -deprecation for details
ev2: Manifest[f2.Bar] = [email protected]#Foo$Bar

scala> ev1 == ev2 // they should be different, thus the result is wrong
res28: Boolean = true

因此,它们被TypeTags代替,它不仅易于使用,而且可以很好地集成到新的Reflection API中。有了它们,我们可以优雅地解决上述有关路径依赖类型的问题:
scala> def m(f: Foo)(b: f.Bar)(implicit ev: TypeTag[f.Bar]) = ev
m: (f: Foo)(b: f.Bar)(implicit ev: reflect.runtime.universe.TypeTag[f.Bar])↩
reflect.runtime.universe.TypeTag[f.Bar]

scala> val ev1 = m(f1)(b1)
ev1: reflect.runtime.universe.TypeTag[f1.Bar] = TypeTag[f1.Bar]

scala> val ev2 = m(f2)(b2)
ev2: reflect.runtime.universe.TypeTag[f2.Bar] = TypeTag[f2.Bar]

scala> ev1 == ev2 // the result is correct, the type tags are different
res30: Boolean = false

scala> ev1.tpe =:= ev2.tpe // this result is correct, too
res31: Boolean = false

它们也很容易用于检查类型参数:
import scala.reflect.runtime.universe._

def meth[A : TypeTag](xs: List[A]) = typeOf[A] match {
  case t if t =:= typeOf[String] => "list of strings"
  case t if t <:< typeOf[Foo] => "list of foos"
}

scala> meth(List("string"))
res67: String = list of strings

scala> meth(List(new Bar))
res68: String = list of foos

在这一点上,理解使用=:=(类型相等)和<:<(子类型关系)进行相等性检查非常重要。切勿使用==!=,除非您完全知道自己要做什么:
scala> typeOf[List[java.lang.String]] =:= typeOf[List[Predef.String]]
res71: Boolean = true

scala> typeOf[List[java.lang.String]] == typeOf[List[Predef.String]]
res72: Boolean = false

后者检查结构是否相等,通常不应该这样做,因为它不关心诸如前缀之类的东西(如示例中所示)。
TypeTag是完全由编译器生成的,这意味着编译器会在调用需要此类TypeTag的方法时创建并填充TypeTag。标签存在三种不同形式:
  • scala.reflect.ClassTag
  • scala.reflect.api.TypeTags#TypeTag
  • scala.reflect.api.TypeTags#WeakTypeTag
  • ClassTag替代ClassManifest,而TypeTag或多或少是Manifest的替代品。

    前者可以完全使用通用数组:
    scala> import scala.reflect._
    import scala.reflect._
    
    scala> def createArr[A](seq: A*) = Array[A](seq: _*)
    <console>:22: error: No ClassTag available for A
           def createArr[A](seq: A*) = Array[A](seq: _*)
                                               ^
    
    scala> def createArr[A : ClassTag](seq: A*) = Array[A](seq: _*)
    createArr: [A](seq: A*)(implicit evidence$1: scala.reflect.ClassTag[A])Array[A]
    
    scala> createArr(1,2,3)
    res78: Array[Int] = Array(1, 2, 3)
    
    scala> createArr("a","b","c")
    res79: Array[String] = Array(a, b, c)
    
    ClassTag仅提供在运行时创建类型所需的信息(已擦除类型):
    scala> classTag[Int]
    res99: scala.reflect.ClassTag[Int] = ClassTag[int]
    
    scala> classTag[Int].runtimeClass
    res100: Class[_] = int
    
    scala> classTag[Int].newArray(3)
    res101: Array[Int] = Array(0, 0, 0)
    
    scala> classTag[List[Int]]
    res104: scala.reflect.ClassTag[List[Int]] =↩
            ClassTag[class scala.collection.immutable.List]
    

    从上面可以看到,他们并不关心类型擦除,因此如果要“完整”类型,则应使用TypeTag:
    scala> typeTag[List[Int]]
    res105: reflect.runtime.universe.TypeTag[List[Int]] = TypeTag[scala.List[Int]]
    
    scala> typeTag[List[Int]].tpe
    res107: reflect.runtime.universe.Type = scala.List[Int]
    
    scala> typeOf[List[Int]]
    res108: reflect.runtime.universe.Type = scala.List[Int]
    
    scala> res107 =:= res108
    res109: Boolean = true
    

    可以看到,tpeTypeTag方法产生完整的Type,这与调用typeOf时得到的相同。当然,可以同时使用ClassTagTypeTag:
    scala> def m[A : ClassTag : TypeTag] = (classTag[A], typeTag[A])
    m: [A](implicit evidence$1: scala.reflect.ClassTag[A],↩
           implicit evidence$2: reflect.runtime.universe.TypeTag[A])↩
          (scala.reflect.ClassTag[A], reflect.runtime.universe.TypeTag[A])
    
    scala> m[List[Int]]
    res36: (scala.reflect.ClassTag[List[Int]],↩
            reflect.runtime.universe.TypeTag[List[Int]]) =↩
           (scala.collection.immutable.List,TypeTag[scala.List[Int]])
    

    现在剩下的问题是WeakTypeTag的含义是什么?简而言之,TypeTag代表具体类型(这意味着它仅允许完全实例化的类型),而WeakTypeTag仅允许任何类型。大多数时候,人们并不在乎哪个是什么(这意味着应该使用TypeTag),但是例如,当使用的宏应该与泛型类型一起使用时,就需要它们:
    object Macro {
      import language.experimental.macros
      import scala.reflect.macros.Context
    
      def anymacro[A](expr: A): String = macro __anymacro[A]
    
      def __anymacro[A : c.WeakTypeTag](c: Context)(expr: c.Expr[A]): c.Expr[A] = {
        // to get a Type for A the c.WeakTypeTag context bound must be added
        val aType = implicitly[c.WeakTypeTag[A]].tpe
        ???
      }
    }
    

    如果将WeakTypeTag替换为TypeTag,则会引发错误:
    <console>:17: error: macro implementation has wrong shape:
     required: (c: scala.reflect.macros.Context)(expr: c.Expr[A]): c.Expr[String]
     found   : (c: scala.reflect.macros.Context)(expr: c.Expr[A])(implicit evidence$1: c.TypeTag[A]): c.Expr[A]
    macro implementations cannot have implicit parameters other than WeakTypeTag evidences
                 def anymacro[A](expr: A): String = macro __anymacro[A]
                                                          ^
    

    有关TypeTagWeakTypeTag之间的区别的更详细说明,请参见以下问题:Scala Macros: “cannot create TypeTag from a type T having unresolved type parameters”

    Scala的官方文档站点还包含guide for Reflection

    09-16 12:46