Scala Reflection Library2.12.21 < Back
 

# Packages

-  package root
  Definition Classes
    root
-  package scala
  Definition Classes
    root
-  package reflect
  Definition Classes
    scala
-  package api

  EXPERIMENTAL

  EXPERIMENTAL

  The Scala Reflection API (located in scala-reflect.jar).

  In Scala 2.10.0, the Scala Reflection API and its implementation have an "experimental" status. This means that the API and the docs are not complete and can be changed in binary- and source-incompatible manner in 2.10.1. This also means that the implementation has some known issues.

  The following types are the backbone of the Scala Reflection API, and serve as a good starting point for information about Scala Reflection:

  - scala.reflect.api.Symbols
  - scala.reflect.api.Types
  - scala.reflect.api.Mirrors
  - scala.reflect.api.Universe

  For more information about Scala Reflection, see the Reflection Guide

  Definition Classes
    reflect
- Annotations
- Constants
- Exprs
- FlagSets
- ImplicitTags
- Internals
- JavaUniverse
- Liftables
- Mirror
- Mirrors
- Names
- Position
- Positions
- Printers
- Quasiquotes
- Scopes
- StandardDefinitions
- StandardLiftables
- StandardNames
- Symbols
- TreeCreator
- Trees
- TypeCreator
- TypeTags
- Types
- Universe

t

scala.reflect.api

# TypeTags 

###

#### trait TypeTags extends AnyRef

A `TypeTag[T]` encapsulates the runtime type representation of some type `T`. Like scala.reflect.Manifest, the prime use case of `TypeTag`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`:

- 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`. `ClassTag`s 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, `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:

    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)

##### `WeakTypeTag`s

`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

`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.10 `Manifest` types do not have a direct correspondence with a 2.10 "`Tag`" type.

- scala.reflect.OptManifest is not supported.
  This is because `Tag`s 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 `Tag`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`.
- 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 `TypeTag`s and `ClassTag`s in an upcoming point release. Thus, it is advisable to migrate any `Manifest`-based APIs to use `Tag`s.

For more information about `TypeTag`s, see the Reflection Guide: TypeTags

Self Type
  Universe
Source
  TypeTags.scala
See also

  scala.reflect.ClassTag, scala.reflect.api.TypeTags#TypeTag, scala.reflect.api.TypeTags#WeakTypeTag

Linear Supertypes
AnyRef, Any
Known Subclasses
JavaUniverse, Universe, Universe
 
Ordering

1. Grouped
2. Alphabetic
3. By Inheritance

Inherited

1. TypeTags
2. AnyRef
3. Any

Implicitly

1. by any2stringadd
2. by StringFormat
3. by Ensuring
4. by ArrowAssoc

1. Hide All
2. Show All

Visibility

1. Public
2. All

### Type Members

1.  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.

   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

     scala.reflect.api.TypeTags

2.  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.

   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

     scala.reflect.api.TypeTags

### Abstract Value Members

1.  abstract def symbolOf[T](implicit arg0: Universe.WeakTypeTag[T]): Universe.TypeSymbol

   Type symbol of `x` as derived from a type tag.

### Concrete Value Members

1.  final def !=(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
2.  final def ##(): Int
   Definition Classes
     AnyRef → Any
3.  def +(other: String): String
   Implicit
     This member is added by an implicit conversion from TypeTags to any2stringadd[TypeTags] performed by method any2stringadd in scala.Predef.
   Definition Classes
     any2stringadd
4.  def ->[B](y: B): (TypeTags, B)
   Implicit
     This member is added by an implicit conversion from TypeTags to ArrowAssoc[TypeTags] performed by method ArrowAssoc in scala.Predef.
   Definition Classes
     ArrowAssoc
   Annotations
     @inline()
5.  final def ==(arg0: Any): Boolean
   Definition Classes
     AnyRef → Any
6.  final def asInstanceOf[T0]: T0
   Definition Classes
     Any
7.  def clone(): AnyRef
   Attributes
     protected[lang]
   Definition Classes
     AnyRef
   Annotations
     @throws( ... ) @native()
8.  def ensuring(cond: (TypeTags) ⇒ Boolean, msg: ⇒ Any): TypeTags
   Implicit
     This member is added by an implicit conversion from TypeTags to Ensuring[TypeTags] performed by method Ensuring in scala.Predef.
   Definition Classes
     Ensuring
9.  def ensuring(cond: (TypeTags) ⇒ Boolean): TypeTags
   Implicit
     This member is added by an implicit conversion from TypeTags to Ensuring[TypeTags] performed by method Ensuring in scala.Predef.
   Definition Classes
     Ensuring
10.  def ensuring(cond: Boolean, msg: ⇒ Any): TypeTags
    Implicit
      This member is added by an implicit conversion from TypeTags to Ensuring[TypeTags] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
11.  def ensuring(cond: Boolean): TypeTags
    Implicit
      This member is added by an implicit conversion from TypeTags to Ensuring[TypeTags] performed by method Ensuring in scala.Predef.
    Definition Classes
      Ensuring
12.  final def eq(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
13.  def equals(arg0: Any): Boolean
    Definition Classes
      AnyRef → Any
14.  def finalize(): Unit
    Attributes
      protected[lang]
    Definition Classes
      AnyRef
    Annotations
      @throws( classOf[java.lang.Throwable] )
15.  final def getClass(): Class[_]
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
16.  def hashCode(): Int
    Definition Classes
      AnyRef → Any
    Annotations
      @native()
17.  final def isInstanceOf[T0]: Boolean
    Definition Classes
      Any
18.  final def ne(arg0: AnyRef): Boolean
    Definition Classes
      AnyRef
19.  final def notify(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
20.  final def notifyAll(): Unit
    Definition Classes
      AnyRef
    Annotations
      @native()
21.  final def synchronized[T0](arg0: ⇒ T0): T0
    Definition Classes
      AnyRef
22.  def toString(): String
    Definition Classes
      AnyRef → Any
23.  def typeOf[T](implicit ttag: Universe.TypeTag[T]): Universe.Type

    Shortcut for `implicitly[TypeTag[T]].tpe`

24.  def typeTag[T](implicit ttag: Universe.TypeTag[T]): Universe.TypeTag[T]

    Shortcut for `implicitly[TypeTag[T]]`

25.  final def wait(): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
26.  final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... )
27.  final def wait(arg0: Long): Unit
    Definition Classes
      AnyRef
    Annotations
      @throws( ... ) @native()
28.  def weakTypeOf[T](implicit attag: Universe.WeakTypeTag[T]): Universe.Type

    Shortcut for `implicitly[WeakTypeTag[T]].tpe`

29.  def weakTypeTag[T](implicit attag: Universe.WeakTypeTag[T]): Universe.WeakTypeTag[T]

    Shortcut for `implicitly[WeakTypeTag[T]]`

30.  def →[B](y: B): (TypeTags, B)
    Implicit
      This member is added by an implicit conversion from TypeTags to ArrowAssoc[TypeTags] performed by method ArrowAssoc in scala.Predef.
    Definition Classes
      ArrowAssoc
31.  object TypeTag extends Serializable

    Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

32.  object WeakTypeTag extends Serializable

    Type tags corresponding to primitive types and constructor/extractor for WeakTypeTags.

### Deprecated Value Members

1.  def formatted(fmtstr: String): String
   Implicit
     This member is added by an implicit conversion from TypeTags to StringFormat[TypeTags] performed by method StringFormat in scala.Predef.
   Definition Classes
     StringFormat
   Annotations
     @deprecated @inline()
   Deprecated

     (Since version 2.12.16) Use `formatString.format(value)` instead of `value.formatted(formatString)`, or use the `f""` string interpolator. In Java 15 and later, `formatted` resolves to the new method in String which has reversed parameters.

### Inherited from AnyRef

### Inherited from Any

### Inherited by implicit conversion any2stringadd from TypeTags to any2stringadd[TypeTags]

### Inherited by implicit conversion StringFormat from TypeTags to StringFormat[TypeTags]

### Inherited by implicit conversion Ensuring from TypeTags to Ensuring[TypeTags]

### Inherited by implicit conversion ArrowAssoc from TypeTags to ArrowAssoc[TypeTags]

### TypeTags

### Ungrouped