Trait scala.reflect.api.TypeTags
trait TypeTags extends AnyRef
Type Members
trait TypeTag[T] extends Universe.WeakTypeTag[T] with Equals with Serializable
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.
- Annotations
- @implicitNotFound ( "No TypeTag available for ${T}" )
- See also
trait WeakTypeTag[T] extends Equals with Serializable
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 TypeTag
s 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 TypeTag
s, see the Reflection Guide: TypeTags
- Annotations
- @implicitNotFound ( "No WeakTypeTag available for ${T}" )
- See also
Abstract Value Members
abstract def symbolOf[T](implicit arg0: Universe.WeakTypeTag[T]): Universe.TypeSymbol
Concrete Value Members
final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
final def ##(): Int
- Definition Classes
- AnyRef → Any
def +(other: String): String
def ->[B](y: B): (TypeTags, B)
final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
final def asInstanceOf[T0]: T0
- Definition Classes
- Any
def clone(): AnyRef
- Attributes
- protected[ lang]
- Definition Classes
- AnyRef
- Annotations
- @throws ( ... ) @native ()
def ensuring(cond: (TypeTags) ⇒ Boolean, msg: ⇒ Any): TypeTags
def ensuring(cond: (TypeTags) ⇒ Boolean): TypeTags
def ensuring(cond: Boolean, msg: ⇒ Any): TypeTags
def ensuring(cond: Boolean): TypeTags
final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
def equals(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
def finalize(): Unit
- Attributes
- protected[ lang]
- Definition Classes
- AnyRef
- Annotations
- @throws ( classOf[java.lang.Throwable] )
def formatted(fmtstr: String): String
final def getClass(): Class[_]
- Definition Classes
- AnyRef → Any
- Annotations
- @native ()
def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native ()
final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native ()
final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native ()
final def synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
def toString(): String
- Definition Classes
- AnyRef → Any
def typeOf[T](implicit ttag: Universe.TypeTag[T]): Universe.Type
def typeTag[T](implicit ttag: Universe.TypeTag[T]): Universe.TypeTag[T]
final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws ( ... )
final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws ( ... )
final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws ( ... ) @native ()
def weakTypeOf[T](implicit attag: Universe.WeakTypeTag[T]): Universe.Type
def weakTypeTag[T](implicit attag: Universe.WeakTypeTag[T]): Universe.WeakTypeTag[T]
def →[B](y: B): (TypeTags, B)
object TypeTag extends Serializable
object WeakTypeTag extends Serializable
© 2002-2019 EPFL, with contributions from Lightbend.
Licensed under the Apache License, Version 2.0.
https://www.scala-lang.org/api/2.12.9/scala-reflect/scala/reflect/api/TypeTags.html
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 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
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