Type Members

1.  trait AbsCompoundType extends Universe.AbsType

   This class declares methods that are visible in a CompoundType (i.e.

   This class declares methods that are visible in a CompoundType (i.e. a class/trait/object template or refined type of the form

   P_1 with ... with P_m { D_1; ...; D_n }

   P_n

2.  trait AbsSingletonType extends Universe.AbsType

   This class declares methods that are visible in a SingleType.

3.  abstract class AbsType extends AnyRef

   This class declares operations that are visible in a Type.

4.  abstract type AnnotatedType <: Universe.Type
5.  abstract class AnnotatedTypeExtractor extends AnyRef
6.  abstract type ClassInfoType <: Universe.CompoundType

   The ClassInfo type signature is used to define parents and declarations of classes, traits, and objects.

   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)

7.  abstract class ClassInfoTypeExtractor extends AnyRef

   An extractor class to create and pattern match with syntax ClassInfo(parents, decls, clazz) Here, parents is the list of parent types of the class, decls is the scope containing all declarations in the class, and clazz is the symbol of the class itself.

8.  abstract type CompoundType <: Universe.Type

   A subtype of Type representing refined types as well as ClassInfo signatures.

9.  abstract type ConstantType <: Universe.SingletonType

   The ConstantType type is not directly written in user programs, but arises as the type of a constant.

   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"))

10.  abstract class ConstantTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ConstantType(constant) Here, constant is the constant value represented by the type.

11.  abstract type ExistentialType <: Universe.Type
12.  abstract class ExistentialTypeExtractor extends AnyRef
13.  abstract type MethodType <: Universe.Type

    The MethodType type signature is used to indicate parameters and result type of a method

14.  abstract class MethodTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax MethodType(params, respte) Here, params is a potentially empty list of parameter symbols of the method, and restpe is the result type of the method.

    An extractor class to create and pattern match with syntax MethodType(params, respte) 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.

15.  abstract type NullaryMethodType <: Universe.Type
16.  abstract class NullaryMethodTypeExtractor extends AnyRef
17.  abstract type PolyType <: Universe.Type
18.  abstract class PolyTypeExtractor extends AnyRef
19.  abstract type RefinedType <: Universe.CompoundType

    The RefinedType type defines types of any of the forms on the left, with their RefinedType representations to the right.

    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))

20.  abstract class RefinedTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax RefinedType(parents, decls) Here, parents is the list of parent types of the class, and decls is the scope containing all declarations in the class.

21.  abstract type SingleType <: Universe.SingletonType

    The SingleType type describes types of any of the forms on the left, with their TypeRef representations to the right.

    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)

22.  abstract class SingleTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax SingleType(pre, sym) Here, pre is the prefix of the single-type, and sym is the stable value symbol referred to by the single-type.

23.  abstract type SingletonType >: Null <: Universe.Type

    The type of Scala singleton types, i.e.

    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.

24.  abstract type SuperType <: Universe.SingletonType

    The SuperType type is not directly written, but arises when C.super is used as a prefix in a TypeRef or SingleType.

    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.

25.  abstract class SuperTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax SingleType(thistpe, supertpe)

26.  abstract type ThisType <: Universe.SingletonType

    The ThisType type describes types of the form on the left with the correspnding ThisType representations to the right.

    The ThisType type describes types of the form on the left with the correspnding ThisType representations to the right.

    C.this.type             ThisType(C)

27.  abstract class ThisTypeExtractor extends AnyRef

    An extractor class to create and pattern match with syntax ThisType(sym) where sym is the class prefix of the this type.

28.  abstract type Type >: Null <: Universe.AbsType

    The type of Scala types, and also Scala type signatures.

    The type of Scala types, and also Scala type signatures. (No difference is internally made between the two).

29.  abstract type TypeBounds <: Universe.Type

    The TypeBounds type signature is used to indicate lower and upper type bounds of type parameters and abstract types.

    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)

30.  abstract class TypeBoundsExtractor extends AnyRef

    An extractor class to create and pattern match with syntax TypeBound(lower, upper) Here, lower is the lower bound of the TypeBounds pair, and upper is the upper bound.

31.  abstract type TypeRef <: Universe.Type

    The TypeRef type describes types of any of the forms on the left, with their TypeRef representations to the right.

    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)

32.  abstract class TypeRefExtractor extends AnyRef

    An extractor class to create and pattern match with syntax TypeRef(pre, sym, args) Here, pre is the prefix of the type reference, sym is the symbol referred to by the type reference, and args is a possible empty list of type argumenrts.