A TypeTag is a scala.reflect.api.TypeTags#WeakTypeTag with the additional
static guarantee that all type references are concrete, i.e.
A TypeTag is a scala.reflect.api.TypeTags#WeakTypeTag with the additional
static guarantee that all type references are concrete, i.e. it does not contain any references to
unresolved type parameters or abstract types.
If an implicit value of type WeakTypeTag[T] is required, the compiler will create one,
and the reflective representation of T can be accessed via the tpe field.
If an implicit value of type WeakTypeTag[T] is required, the compiler will create one,
and the reflective representation of T can be accessed via the tpe field.
Components of T can be references to type parameters or abstract types. Note that WeakTypeTag
makes an effort to be as concrete as possible, i.e. if TypeTags are available for the referenced type arguments
or abstract types, they are used to embed the concrete types into the WeakTypeTag. Otherwise the WeakTypeTag will
contain a reference to an abstract type. This behavior can be useful, when one expects T to be perhaps be partially
abstract, but requires special care to handle this case. However, if T is expected to be fully known, use
scala.reflect.api.TypeTags#TypeTag instead, which statically guarantees this property.
For more information about TypeTags, see the
Reflection Guide: TypeTags
Type symbol of x as derived from a type tag.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Shortcut for implicitly[TypeTag[T]].tpe
Shortcut for implicitly[TypeTag[T]]
Shortcut for implicitly[WeakTypeTag[T]].tpe
Shortcut for implicitly[WeakTypeTag[T]]
A
TypeTag[T]encapsulates the runtime type representation of some typeT. Like scala.reflect.Manifest, the prime use case ofTypeTags 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:A full type descriptor of a Scala type. For example, a
TypeTag[List[String]]contains all type information, in this case, of typescala.List[String].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 typescala.collection.immutable.List.ClassTags provide access only to the runtime class of a type. Analogous to scala.reflect.ClassManifestA 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:
Each of these methods constructs a
TypeTag[T]orClassTag[T]for the given type argumentT.#2 Using an implicit parameter of type
TypeTag[T],ClassTag[T], orWeakTypeTag[T]For example:
#3 Context bound of a type parameter
...on methods or classes. The above example can be implemented as follows:
WeakTypeTagsWeakTypeTag[T]generalizesTypeTag[T]. Unlike a regularTypeTag, 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 theWeakTypeTag[T].Continuing the example above:
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.10Manifesttypes do not have a direct correspondence with a 2.10 "Tag" type.This is because
Tags can reify arbitrary types, so they are always available. -Instead, one can compare their
Tagwith one of the baseTags (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.Manifestcompanion objects.Instead, one could generate corresponding types using the reflection APIs provided by Java (for classes) and Scala (for types).
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 andClassTags in an upcoming point release. Thus, it is advisable to migrate anyManifest-based APIs to useTags.For more information about
TypeTags, see the Reflection Guide: TypeTagsscala.reflect.ClassTag, scala.reflect.api.TypeTags#TypeTag, scala.reflect.api.TypeTags#WeakTypeTag