TypeVar

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

Test two objects for inequality.

final def ##(): Int

Equivalent to x.hashCode except for boxed numeric types and null.

def +(other: String): String

def ->[B](y: B): (TypeVar, B)

def <:<(that: Type): Boolean

Is this type a subtype of that type?

def =:=(that: Type): Boolean

Is this type equivalent to that type?

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

Test two objects for equality.

def addHiBound(tp: Type, isNumericBound: Boolean = false): Unit

def addLoBound(tp: Type, isNumericBound: Boolean = false): Unit

def annotations: List[AnnotationInfo]

The annotations on this type.

def applyArgs(newArgs: List[Type]): TypeVar

Two occurrences of a higher-kinded typevar, e.

final def asInstanceOf[T0]: T0

Cast the receiver object to be of type T0.

def asSeenFrom(pre: Type, clazz: Symbol): Type

This type as seen from prefix pre and class clazz.

def atOwner(owner: Symbol): Type

Make sure this type is correct as the info of given owner; clone it if not.

def baseClasses: List[Symbol]

The list of all baseclasses of this type (including its own typeSymbol) in reverse linearization order, starting with the class itself and ending in class Any.

def baseType(clazz: Symbol): Type

The least type instance of given class which is a supertype of this type.

def baseTypeIndex(sym: Symbol): Int

def baseTypeSeq: BaseTypeSeq

The shortest sorted upwards closed array of types that contains this type as first element.

def baseTypeSeqDepth: Int

The maximum depth (@see typeDepth) of each type in the BaseTypeSeq of this type except the first.

def betaReduce: Type

Performs a single step of beta-reduction on types.

def boundSyms: Set[Symbol]

For a (potentially wrapped) poly or existential type, its bound symbols, the empty list for all other types

def bounds: TypeBounds

For a TypeBounds type, itself; for a reference denoting an abstract type, its bounds, for all other types, a TypeBounds type all of whose bounds are this type.

def clone(): AnyRef

Create a copy of the receiver object.

def cloneInfo(owner: Symbol): Type

If this is a poly- or methodtype, a copy with cloned type / value parameters owned by owner.

def cloneInternal: TypeVar

def collect[T](pf: PartialFunction[Type, T]): List[T]

Apply pf' to each part of this type on which the function is defined

def complete(sym: Symbol): Unit

If this is a lazy type, assign a new type to sym.

def computeMemberType(sym: Symbol): Type

var constr: TypeConstraint

The constraint associated with the variable Syncnote: Type variables are assumed to be used from only one thread.

val constr0: TypeConstraint

def contains(sym: Symbol): Boolean

Does this type contain a reference to this symbol?

def containsTp(tp: Type): Boolean

Does this type contain a reference to this type

def dealias: Type

Expands type aliases.

def decl(name: Name): Symbol

The defined or declared members with name name in this type; an OverloadedSymbol if several exist, NoSymbol if none exist.

def declaration(name: Name): Symbol

The defined or declared members with name name in this type; an OverloadedSymbol if several exist, NoSymbol if none exist.

def declarations: Scope

The collection of declarations in this type [Eugene++] why not List?

def decls: Scope

For a classtype or refined type, its defined or declared members; inherited by subtypes and typerefs.

def deconst: Type

Map a constant type or not-null-type to its underlying base type, identity for all other types.

def deferredMembers: List[Symbol]

A list of all deferred symbols of this type (defined or inherited)

def directObjectString: String

The string representation of this type when the direct object in a sentence.

def dummyArgs: List[Type]

A list of placeholder types derived from the type parameters.

def ensuring(cond: (TypeVar) ⇒ Boolean, msg: ⇒ Any): TypeVar

def ensuring(cond: (TypeVar) ⇒ Boolean): TypeVar

def ensuring(cond: Boolean, msg: ⇒ Any): TypeVar

def ensuring(cond: Boolean): TypeVar

final def eq(arg0: AnyRef): Boolean

Tests whether the argument (arg0) is a reference to the receiver object (this).

def equals(arg0: Any): Boolean

The equality method for reference types.

def erasure: Type

The erased type corresponding to this type after all transformations from Scala to Java have been performed.

def etaExpand: Type

def exists(p: (Type) ⇒ Boolean): Boolean

Is there part of this type which satisfies predicate p?

def filter(p: (Type) ⇒ Boolean): List[Type]

Returns all parts of this type which satisfy predicate p

def filterAnnotations(p: (AnnotationInfo) ⇒ Boolean): Type

def finalResultType: Type

For a curried/nullary method or poly type its non-method result type, the type itself for all other types

def finalize(): Unit

Called by the garbage collector on the receiver object when there are no more references to the object.

def find(p: (Type) ⇒ Boolean): Option[Type]

Returns optionally first type (in a preorder traversal) which satisfies predicate p, or None if none exists.

def findMember(name: Name, excludedFlags: Long, requiredFlags: Long, stableOnly: Boolean): Symbol

Find member(s) in this type.

def firstParent: Type

For a class with nonEmpty parents, the first parent.

def foreach(f: (Type) ⇒ Unit): Unit

Apply f to each part of this type

def formatted(fmtstr: String): String

Returns string formatted according to given format string.

def getAnnotation(cls: Symbol): Option[AnnotationInfo]

final def getClass(): Class[_]

A representation that corresponds to the dynamic class of the receiver object.

def hasAnnotation(cls: Symbol): Boolean

Test for, get, or remove an annotation

def hashCode(): Int

The hashCode method for reference types.

def implicitMembers: List[Symbol]

A list of all implicit symbols of this type (defined or inherited)

def instValid: Boolean

def instantiateTypeParams(formals: List[Symbol], actuals: List[Type]): Type

Replace formal type parameter symbols with actual type arguments.

def isComplete: Boolean

Is this type completed (i.

def isConcrete: Boolean

Does this type refer to spliceable types or is a spliceable type?

def isDependent: Boolean

Does this depend on an enclosing method parameter?

def isErroneous: Boolean

Is this type produced as a repair for an error?

def isError: Boolean

Is this type produced as a repair for an error?

def isFinalType: Boolean

Can this type only be subtyped by bottom types? This is assessed to be the case if the class is final, and all type parameters (if any) are invariant.

def isGround: Boolean

A test whether a type contains any unification type variables.

def isHigherKinded: Boolean

Is this type higher-kinded, i.

def isImmediatelyDependent: Boolean

Does this type depend immediately on an enclosing method parameter? I.

final def isInstanceOf[T0]: Boolean

Test whether the dynamic type of the receiver object is T0.

def isNotNull: Boolean

Is this type guaranteed not to have null as a value?

def isRelatable(tp: Type): Boolean

Can this variable be related in a constraint to type tp? This is not the case if tp contains type skolems whose skolemization level is higher than the level of this variable.

def isSpliceable: Boolean

Is this type an abstract type that needs to be resolved?

def isStable: Boolean

Does this type denote a stable reference (i.

def isStructuralRefinement: Boolean

Is this type a structural refinement type (it refines members that have not been inherited)

def isTrivial: Boolean

Types for which asSeenFrom always is the identity, no matter what prefix or owner.

def isVolatile: Boolean

Is this type dangerous (i.

def isWildcard: Boolean

True for WildcardType or BoundedWildcardType.

def kind: String

The kind of this type; used for debugging

val level: Int

The variable's skolemization level

def load(sym: Symbol): Unit

If this is a symbol loader type, load and assign a new type to sym.

def looselyMatches(that: Type): Boolean

Same as matches, except that non-method types are always assumed to match.

def map(f: (Type) ⇒ Type): Type

Apply f to each part of this type; children get mapped before their parents

def matches(that: Type): Boolean

Is this type close enough to that type so that members with the two type would override each other? This means:

def matchesPattern(that: Type): Boolean

Is this type a subtype of that type in a pattern context? Any type arguments on the right hand side are replaced with fresh existentials, except for Arrays.

def member(name: Name): Symbol

The member with given name, an OverloadedSymbol if several exist, NoSymbol if none exist

def memberBasedOnName(name: Name, excludedFlags: Long): Symbol

def memberInfo(sym: Symbol): Type

The info of sym, seen as a member of this type.

class D[T] { def m: T }
class C extends p.D[Int]
ThisType(C).memberType(m) = Int

def memberType(sym: Symbol): Type

The type of sym, seen as a member of this type.

def members: List[Symbol]

A list of all members of this type (defined or inherited) Members appear in linearization order of their owners.

def membersBasedOnFlags(excludedFlags: Long, requiredFlags: Long): List[Symbol]

Members excluding and requiring the given flags.

def membersWithFlags(requiredFlags: Long): List[Symbol]

All members with the given flags, excluding bridges.

def narrow: Type

Map to a singleton type which is a subtype of this type.

T.narrow  =  (T {}).this.type

final def ne(arg0: AnyRef): Boolean

Equivalent to !(this eq that).

def nonLocalMember(name: Name): Symbol

The non-local member with given name, an OverloadedSymbol if several exist, NoSymbol if none exist

def nonPrivateDecl(name: Name): Symbol

The non-private defined or declared members with name name in this type; an OverloadedSymbol if several exist, NoSymbol if none exist.

def nonPrivateDeclaration(name: Name): Symbol

def nonPrivateDecls: List[Symbol]

A list of all non-private members defined or declared in this type.

def nonPrivateMember(name: Name): Symbol

The non-private member with given name, an OverloadedSymbol if several exist, NoSymbol if none exist.

def nonPrivateMemberAdmitting(name: Name, admit: Long): Symbol

The non-private member with given name, admitting members with given flags admit.

def nonPrivateMembers: List[Symbol]

A list of all non-private members of this type (defined or inherited)

def nonPrivateMembersAdmitting(admit: Long): List[Symbol]

A list of all non-private members of this type (defined or inherited), admitting members with given flags admit

def nonPrivateMembersWithFlags(requiredFlags: Long): List[Symbol]

All non-private members with the given flags, excluding bridges.

def normalize: Type

Reduce to beta eta-long normal form.

def notNull: Type

Mixin a NotNull trait unless type already has one .

final def notify(): Unit

Wakes up a single thread that is waiting on the receiver object's monitor.

final def notifyAll(): Unit

Wakes up all threads that are waiting on the receiver object's monitor.

def objectPrefix: String

val origin: Type

def originLocation: String

def originName: String

def packagePrefix: String

def paramSectionCount: Int

For a method type, the number of its value parameter sections, 0 for all other types

def paramTypes: List[Type]

For a method or poly type, the types of its first value parameter section, the empty list for all other types

def params: List[Symbol]

For a method or poly type, its first value parameter section, the empty list for all other types

def paramss: List[List[Symbol]]

For a method or poly type, a list of its value parameter sections, the empty list for all other types

def parents: List[Type]

For a class or intersection type, its parents.

def prefix: Type

For a typeref or single-type, the prefix of the normalized type (@see normalize).

def prefixChain: List[Type]

A chain of all typeref or singletype prefixes of this type, longest first.

def prefixString: String

The string representation of this type used as a prefix

def registerBound(tp: Type, isLowerBound: Boolean, isNumericBound: Boolean = false): Boolean

Called when a TypeVar is involved in a subtyping check.

def registerTypeEquality(tp: Type, typeVarLHS: Boolean): Boolean

def registerTypeSelection(sym: Symbol, tp: Type): Boolean

?A.T =:= tp is rewritten as the constraint ?A <: {type T = tp}

def remove(clazz: Symbol): Type

If this is a TypeRef clazz[T], return the argument T otherwise return this type

def removeAnnotation(cls: Symbol): Type

def resultApprox: Type

Only used for dependent method types.

def resultType(actuals: List[Type]): Type

def resultType: Type

For a (nullary) method or poly type, its direct result type, the type itself for all other types.

def safeToString: String

Method to be implemented in subclasses.

def selfsym: Symbol

The selfsym of an annotated type, or NoSymbol of anything else

def setAnnotations(annots: List[AnnotationInfo]): Type

def setInst(tp: Type): Unit

def skolemizeExistential: Type

A simple version of skolemizeExistential for situations where owner or unpack location do not matter (typically used in subtype tests)

def skolemizeExistential(owner: Symbol, origin: AnyRef): Type

If this type is an existential, turn all existentially bound variables to type skolems.

def skolemsExceptMethodTypeParams: List[Symbol]

The (existential or otherwise) skolems and existentially quantified variables which are free in this type

def specializes(sym: Symbol): Boolean

Does this type implement symbol sym with same or stronger type?

def stat_<:<(that: Type): Boolean

def stripAnnotations: Type

Remove any annotations from this type and from any types embedded in this type.

def subst(from: List[Symbol], to: List[Type]): Type

Substitute types to for occurrences of references to symbols from in this type.

def substSym(from: List[Symbol], to: List[Symbol]): Type

Substitute symbols to for occurrences of symbols from in this type.

def substThis(from: Symbol, to: Symbol): Type

def substThis(from: Symbol, to: Type): Type

Substitute all occurrences of ThisType(from) in this type by to.

def substThisAndSym(from: Symbol, to: Type, symsFrom: List[Symbol], symsTo: List[Symbol]): Type

Performs both substThis and substSym, in that order.

def substituteSymbols(from: List[Symbol], to: List[Symbol]): Type

Substitute symbols in to for corresponding occurrences of references to symbols from in this type.

def substituteTypes(from: List[Symbol], to: List[Type]): Type

Substitute types in to for corresponding occurrences of references to symbols from in this type.

final def synchronized[T0](arg0: ⇒ T0): T0

def termSymbol: Symbol

The term symbol associated with the type Note that the symbol of the normalized type is returned (@see normalize)

def termSymbolDirect: Symbol

The term symbol directly associated with the type.

def throwsAnnotations(): List[Symbol]

Symbols of any @throws annotations on this symbol.

def toLongString: String

The string representation of this type, with singletypes explained.

def toString(): String

Convert toString avoiding infinite recursions by cutting off after maxTostringRecursions recursion levels.

def trimPrefix(str: String): String

def typeArgs: List[Type]

For a typeref, its arguments.

def typeArguments: List[Type]

If this is a parameterized types, the type arguments.

def typeConstructor: Type

This type, without its type arguments @M

def typeOfThis: Type

The type of this of a class type or reference type.

def typeParams: List[Symbol]

For a (potentially wrapped) poly type, its type parameters, the empty list for all other types

def typeSymbol: Symbol

The type symbol associated with the type Note that the symbol of the normalized type is returned (@see normalize) A type's typeSymbol should if possible not be inspected directly, due to the likelihood that what is true for tp.

def typeSymbolDirect: Symbol

The type symbol directly associated with the type.

def typeVarString: String

def underlying: Type

The base type underlying a type proxy, identity on all other types

def untouchable: Boolean

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def weak_<:<(that: Type): Boolean

Is this type a weak subtype of that type? True also for numeric types, i.

def widen: Type

Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences, identity for all other types.

final def withAnnotation(annot: AnnotationInfo): Type

def withAnnotations(annots: List[AnnotationInfo]): Type

def withFilter(p: (Type) ⇒ Boolean): FilterMapForeach

def withSelfsym(sym: Symbol): Type

Set the self symbol of an annotated type, or do nothing otherwise.

def withoutAnnotations: Type

def →[B](y: B): (TypeVar, B)

val self: Any

val self: Any

def x: TypeVar

def x: TypeVar