Trait scala.reflect.api.Types
trait Types extends AnyRef
Type Members
abstract type AnnotatedType >: Null <: Universe.AnnotatedTypeApi with Universe.Type
trait AnnotatedTypeApi extends Universe.TypeApi
The API that all annotated types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class AnnotatedTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax AnnotatedType(annotations, underlying)
. Here, annotations
are the annotations decorating the underlying type underlying
. selfSym
is a symbol representing the annotated type itself.
abstract type BoundedWildcardType >: Null <: Universe.BoundedWildcardTypeApi with Universe.Type
BoundedWildcardTypes, used only during type inference, are created in two places:
-
If the expected type of an expression is an existential type, its hidden symbols are replaced with bounded wildcards. 2. When an implicit conversion is being sought based in part on the name of a method in the converted type, a HasMethodMatching type is created: a MethodType with parameters typed as BoundedWildcardTypes.
trait BoundedWildcardTypeApi extends Universe.TypeApi
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class BoundedWildcardTypeExtractor extends AnyRef
abstract type ClassInfoType >: Null <: Universe.ClassInfoTypeApi with Universe.CompoundType
The ClassInfo
type signature is used to define parents and declarations of classes, traits, and objects. If a class, trait, or object C is declared like this
C extends P_1 with ... with P_m { D_1; ...; D_n}
its ClassInfo
type has the following form:
ClassInfo(List(P_1, ..., P_m), Scope(D_1, ..., D_n), C)
trait ClassInfoTypeApi extends Universe.TypeApi
The API that all class info types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class ClassInfoTypeExtractor extends AnyRef
abstract type CompoundType >: Null <: Universe.CompoundTypeApi with Universe.Type
trait CompoundTypeApi extends AnyRef
Has no special methods. Is here to provides erased identity for CompoundType
.
abstract type ConstantType >: Null <: Universe.ConstantTypeApi with Universe.SingletonType
The ConstantType
type is not directly written in user programs, but arises as the type of a constant. The REPL expresses constant types like Int(11)
. Here are some constants with their types:
1 ConstantType(Constant(1)) "abc" ConstantType(Constant("abc"))
trait ConstantTypeApi extends Universe.TypeApi
The API that all constant types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class ConstantTypeExtractor extends AnyRef
abstract type ExistentialType >: Null <: Universe.ExistentialTypeApi with Universe.Type
trait ExistentialTypeApi extends Universe.TypeApi
The API that all existential types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class ExistentialTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax ExistentialType(quantified, underlying)
. Here, quantified
are the type variables bound by the existential type and underlying
is the type that's existentially quantified.
abstract type MethodType >: Null <: Universe.MethodTypeApi with Universe.Type
trait MethodTypeApi extends Universe.TypeApi
The API that all method types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class MethodTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax MethodType(params, restpe)
Here, params
is a potentially empty list of parameter symbols of the method, and restpe
is the result type of the method. If the method is curried, restpe
would be another MethodType
. Note: MethodType(Nil, Int)
would be the type of a method defined with an empty parameter list.
def f(): Int
If the method is completely parameterless, as in
def f: Int
its type is a NullaryMethodType
.
abstract type NullaryMethodType >: Null <: Universe.NullaryMethodTypeApi with Universe.Type
trait NullaryMethodTypeApi extends Universe.TypeApi
The API that all nullary method types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class NullaryMethodTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax NullaryMethodType(resultType)
. Here, resultType
is the result type of the parameterless method.
abstract type PolyType >: Null <: Universe.PolyTypeApi with Universe.Type
trait PolyTypeApi extends Universe.TypeApi
The API that all polymorphic types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class PolyTypeExtractor extends AnyRef
An extractor class to create and pattern match with syntax PolyType(typeParams, resultType)
. Here, typeParams
are the type parameters of the method and resultType
is the type signature following the type parameters.
abstract type RefinedType >: Null <: Universe.RefinedTypeApi with Universe.CompoundType
The RefinedType
type defines types of any of the forms on the left, with their RefinedType representations to the right.
P_1 with ... with P_m { D_1; ...; D_n} RefinedType(List(P_1, ..., P_m), Scope(D_1, ..., D_n)) P_1 with ... with P_m RefinedType(List(P_1, ..., P_m), Scope()) { D_1; ...; D_n} RefinedType(List(AnyRef), Scope(D_1, ..., D_n))
trait RefinedTypeApi extends Universe.TypeApi
The API that all refined types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class RefinedTypeExtractor extends AnyRef
abstract type SingleType >: Null <: Universe.SingleTypeApi with Universe.SingletonType
The SingleType
type describes types of any of the forms on the left, with their TypeRef representations to the right.
(T # x).type SingleType(T, x) p.x.type SingleType(p.type, x) x.type SingleType(NoPrefix, x)
trait SingleTypeApi extends Universe.TypeApi
The API that all single types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class SingleTypeExtractor extends AnyRef
abstract type SingletonType >: Null <: Universe.SingletonTypeApi with Universe.Type
The type of Scala singleton types, i.e., types that are inhabited by only one nun-null value. These include types of the forms
C.this.type C.super.type x.type
as well as constant types.
trait SingletonTypeApi extends AnyRef
Has no special methods. Is here to provides erased identity for SingletonType
.
abstract type SuperType >: Null <: Universe.SuperTypeApi with Universe.SingletonType
The SuperType
type is not directly written, but arises when C.super
is used as a prefix in a TypeRef
or SingleType
. It's internal presentation is
SuperType(thistpe, supertpe)
Here, thistpe
is the type of the corresponding this-type. For instance, in the type arising from C.super, the thistpe
part would be ThisType(C)
. supertpe
is the type of the super class referred to by the super
.
trait SuperTypeApi extends Universe.TypeApi
The API that all super types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class SuperTypeExtractor extends AnyRef
abstract type ThisType >: Null <: Universe.ThisTypeApi with Universe.SingletonType
A singleton type that describes types of the form on the left with the corresponding ThisType
representation to the right:
C.this.type ThisType(C)
trait ThisTypeApi extends Universe.TypeApi
The API that all this types support. The main source of information about types is the scala.reflect.api.Types page.
abstract class ThisTypeExtractor extends AnyRef
abstract type Type >: Null <: Universe.TypeApi
The type of Scala types, and also Scala type signatures. (No difference is internally made between the two).
abstract class TypeApi extends AnyRef
The API of types. The main source of information about types is the scala.reflect.api.Types page.
abstract type TypeBounds >: Null <: Universe.TypeBoundsApi with Universe.Type
The TypeBounds
type signature is used to indicate lower and upper type bounds of type parameters and abstract types. It is not a first-class type. If an abstract type or type parameter is declared with any of the forms on the left, its type signature is the TypeBounds type on the right.
T >: L <: U TypeBounds(L, U) T >: L TypeBounds(L, Any) T <: U TypeBounds(Nothing, U)
trait TypeBoundsApi extends Universe.TypeApi
The API that all type bounds support. The main source of information about types is the scala.reflect.api.Types page.
abstract class TypeBoundsExtractor extends AnyRef
abstract type TypeRef >: Null <: Universe.TypeRefApi with Universe.Type
The TypeRef
type describes types of any of the forms on the left, with their TypeRef representations to the right.
T # C[T_1, ..., T_n] TypeRef(T, C, List(T_1, ..., T_n)) p.C[T_1, ..., T_n] TypeRef(p.type, C, List(T_1, ..., T_n)) C[T_1, ..., T_n] TypeRef(NoPrefix, C, List(T_1, ..., T_n)) T # C TypeRef(T, C, Nil) p.C TypeRef(p.type, C, Nil) C TypeRef(NoPrefix, C, Nil)
trait TypeRefApi extends Universe.TypeApi
The API that all type refs support. The main source of information about types is the scala.reflect.api.Types page.
abstract class TypeRefExtractor extends AnyRef
Abstract Value Members
abstract val AnnotatedType: Universe.AnnotatedTypeExtractor
abstract val BoundedWildcardType: Universe.BoundedWildcardTypeExtractor
abstract val ClassInfoType: Universe.ClassInfoTypeExtractor
abstract val ConstantType: Universe.ConstantTypeExtractor
abstract val ExistentialType: Universe.ExistentialTypeExtractor
abstract val MethodType: Universe.MethodTypeExtractor
abstract val NoPrefix: Universe.Type
This constant is used as a special value denoting the empty prefix in a path dependent type. For instance x.type
is represented as SingleType(NoPrefix, <x>)
, where <x>
stands for the symbol for x
.
abstract val NoType: Universe.Type
abstract val NullaryMethodType: Universe.NullaryMethodTypeExtractor
abstract val PolyType: Universe.PolyTypeExtractor
abstract val RefinedType: Universe.RefinedTypeExtractor
abstract val SingleType: Universe.SingleTypeExtractor
abstract val SuperType: Universe.SuperTypeExtractor
abstract val ThisType: Universe.ThisTypeExtractor
abstract val TypeBounds: Universe.TypeBoundsExtractor
abstract val TypeRef: Universe.TypeRefExtractor
abstract val WildcardType: Universe.Type
An object representing an unknown type, used during type inference. If you see WildcardType outside of inference it is almost certainly a bug.
abstract def appliedType(sym: Universe.Symbol, args: Universe.Type*): Universe.Type
- See also
abstract def appliedType(sym: Universe.Symbol, args: List[Universe.Type]): Universe.Type
- See also
abstract def appliedType(tycon: Universe.Type, args: Universe.Type*): Universe.Type
- See also
abstract def appliedType(tycon: Universe.Type, args: List[Universe.Type]): Universe.Type
abstract def glb(ts: List[Universe.Type]): Universe.Type
abstract def lub(xs: List[Universe.Type]): Universe.Type
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): (Types, 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: (Types) ⇒ Boolean, msg: ⇒ Any): Types
def ensuring(cond: (Types) ⇒ Boolean): Types
def ensuring(cond: Boolean, msg: ⇒ Any): Types
def ensuring(cond: Boolean): Types
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
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 →[B](y: B): (Types, B)
© 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/Types.html
EXPERIMENTAL
A trait that defines types and operations on them.
Type instances represent information about the type of a corresponding symbol. This includes its members (methods, fields, type parameters, nested classes, traits, etc.) either declared directly or inherited, its base types, its erasure and so on. Types also provide operations to test for type conformance or equivalence or for widening.
To instantiate a type, most of the time, the scala.reflect.api.TypeTags#typeOf method can be used. It takes a type argument and produces a
Type
instance which represents that argument. For example:In this example, a scala.reflect.api.Types#TypeRef is returned, which corresponds to the type constructor
List
applied to the type argumentInt
.Note: Method
typeOf
does not work for types with type parameters, such astypeOf[List[A]]
whereA
is a type parameter. In this case, use scala.reflect.api.TypeTags#weakTypeOf instead.For other ways to instantiate types, see the corresponding section of the Reflection Guide.
Common Operations on Types
Types are typically used for type conformance tests or are queried for declarations of members or inner types.
<:<
andweak_<:<
.=:=
. It's important to note that==
should not be used to compare types for equality--==
can't check for type equality in the presence of type aliases, while=:=
can.Types can be queried for members and declarations by using the
members
anddeclarations
methods (along with their singular counterpartsmember
anddeclaration
), which provide the list of definitions associated with that type. For example, to look up themap
method ofList
, one can do:For more information about
Type
s, see the Reflection Guide: Symbols, Trees, and Types