A TypeTag
is a scala.reflect.api.TypeTags#WeakTypeTag with the additional
static guarantee that all type references are concrete, i.
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.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.
Returns string formatted according to given format
string.
Returns string formatted according to given format
string.
Format strings are as for String.format
(@see java.lang.String.format).
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 ofTypeTag
s is to give access to erased types. However,TypeTag
s 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
.ClassTag
s 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,
TypeTag
s 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:
WeakTypeTag
sWeakTypeTag[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
TypeTag
s 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.10Manifest
types do not have a direct correspondence with a 2.10 "Tag
" type.This is because
Tag
s can reify arbitrary types, so they are always available. -Instead, one can compare their
Tag
with one of the baseTag
s (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
.Manifest
companion objects.Instead, one could generate corresponding types using the reflection APIs provided by Java (for classes) and Scala (for types).
Instead, one culd 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
TypeTag
s andClassTag
s in an upcoming point release. Thus, it is advisable to migrate anyManifest
-based APIs to useTag
s.For more information about
TypeTag
s, see the Reflection Guide: TypeTagsscala.reflect.ClassTag, scala.reflect.api.TypeTags#TypeTag, scala.reflect.api.TypeTags#WeakTypeTag