A TypeTag[T] encapsulates the runtime type representation of some type T. Like scala.reflect.Manifest, the prime use case of TypeTags is to give access to erased types. However, TypeTags should be considered to be a richer replacement of the pre-2.10 notion of a Manifest, that are, in addition, fully integrated with Scala reflection.

There exist three different types of TypeTags:

• scala.reflect.api.TypeTags#TypeTag.
  A full type descriptor of a Scala type. For example, a TypeTag[List[String]] contains all type information, in this case, of type scala.List[String].
• scala.reflect.ClassTag.
  A partial type descriptor of a Scala type. For example, a ClassTag[List[String]] contains only the erased class type information, in this case, of type scala.collection.immutable.List. ClassTags provide access only to the runtime class of a type. Analogous to scala.reflect.ClassManifest
• scala.reflect.api.TypeTags#WeakTypeTag.
  A type descriptor for abstract types (see description below).

Like Manifests, TypeTags are always generated by the compiler, and can be obtained in three ways:

#1 Via the methods typeTag, classTag, or weakTypeTag

For example:

import scala.reflect.runtime.universe._
val tt = typeTag[Int]

import scala.reflect._
val ct = classTag[String]

Each of these methods constructs a TypeTag[T] or ClassTag[T] for the given type argument T.

#2 Using an implicit parameter of type TypeTag[T], ClassTag[T], or WeakTypeTag[T]

For example:

import scala.reflect.runtime.universe._

def paramInfo[T](x: T)(implicit tag: TypeTag[T]): Unit = {
  val targs = tag.tpe match { case TypeRef(_, _, args) => args }
  println(s"type of $x has type arguments $targs")
}

scala> paramInfo(42)
type of 42 has type arguments List()

scala> paramInfo(List(1, 2))
type of List(1, 2) has type arguments List(Int)

#3 Context bound of a type parameter

...on methods or classes. The above example can be implemented as follows:

import scala.reflect.runtime.universe._

def paramInfo[T: TypeTag](x: T): Unit = {
  val targs = typeOf[T] match { case TypeRef(_, _, args) => args }
  println(s"type of $x has type arguments $targs")
}

scala> paramInfo(42)
type of 42 has type arguments List()

scala> paramInfo(List(1, 2))
type of List(1, 2) has type arguments List(Int)

WeakTypeTags

WeakTypeTag[T] generalizes TypeTag[T]. Unlike a regular TypeTag, components of its type representation can be references to type parameters or abstract types. However, WeakTypeTag[T] tries to be as concrete as possible, i.e. if type tags are available for the referenced type arguments or abstract types, they are used to embed the concrete types into the WeakTypeTag[T].

Continuing the example above:

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")
}

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

scala> foo[Int]
type of List() has type arguments List(T)

TypeTags and Manifests

TypeTags correspond loosely to the pre-2.10 notion of scala.reflect.Manifests. While scala.reflect.ClassTag corresponds to scala.reflect.ClassManifest and scala.reflect.api.TypeTags#TypeTag mostly corresponds to scala.reflect.Manifest, other pre-2.10 Manifest types do not have a direct correspondence with a 2.10 "Tag" type.

• scala.reflect.OptManifest is not supported.
  This is because Tags can reify arbitrary types, so they are always available. -
• There is no equivalent for scala.reflect.AnyValManifest.
  Instead, one can compare their Tag with one of the base Tags (defined in the corresponding companion objects) in order to find out whether or not it represents a primitive value class. Additionally, it's possible to simply use <tag>.tpe.typeSymbol.isPrimitiveValueClass.
• There are no replacement for factory methods defined in the Manifest companion objects.
  Instead, one could generate corresponding types using the reflection APIs provided by Java (for classes) and Scala (for types).
• Certain manifest operations(i.e., <:<, >:> and typeArguments) are not supported.
  Instead, one could use the reflection APIs provided by Java (for classes) and Scala (for types).

In Scala 2.10, scala.reflect.ClassManifests are deprecated, and it is planned to deprecate scala.reflect.Manifest in favor of TypeTags and ClassTags in an upcoming point release. Thus, it is advisable to migrate any Manifest-based APIs to use Tags.

For more information about TypeTags, see the Reflection Guide: TypeTags