TypeRepr

Is this type a subtype of that type?

Is self type the same as that type? This is the case iff self <:< that and that <:< self.

The current type applied to given type arguments: this[targ]

The current type applied to given type arguments: this[targ0, ..., targN]

Convert this TypeRepr to an Type[?]

Usage:

import scala.quoted.*
def f(using Quotes) = {
  val q: Quotes = summon[Quotes]
  import q.reflect.*
  val typeRepr: TypeRepr = ???
  typeRepr.asType match
    case '[t] =>
      '{ val x: t = ??? }
}

The base classes of this type with the class itself as first element.

The least type instance of given class which is a super-type of this type. Example:

  class D[T]
  class C extends p.D[Int]
  ThisType(C).baseType(D) = p.D[Int]

Follow aliases, annotated types until type is no longer alias type, annotated type.

Follow non-opaque aliases, annotated types until type is no longer alias type, annotated type.

Is this type an instance of a non-bottom subclass of the given class cls?

Is this type an context function type?

Is this type a dependent function type?

Is this type a function type with erased parameters?

Is this type a function type?

Is this type a TupleN type?

The type of member as seen from prefix self.

Also see typeRef and termRef

The type <this . sym>, reduced if possible

Shows the type as a String

A simplified version of this type which is equivalent wrt =:= to this type. Reduces typerefs, applied match types, and and or types.

Substitute all types that refer in their symbol attribute to one of the symbols in from by the corresponding types in to.

The applied type arguments (empty if there is no such arguments)

Widen from singleton type to its underlying non-singleton base type by applying one or more underlying dereferences, Also go from => T to T. Identity for all other types. Example:

class Outer { class C ; val x: C } def o: Outer <o.x.type>.widen = o.C

Widen from ByName type to its result type.

Widen from TermRef to its underlying non-termref base type, while also skipping ByName types.

Compares the receiver object (this) with the argument object (that) for equivalence.

Any implementation of this method should be an equivalence relation:

• It is reflexive: for any instance x of type Any, x.equals(x) should return true.
• It is symmetric: for any instances x and y of type Any, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any instances x, y, and z of type Any if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.

If you override this method, you should verify that your implementation remains an equivalence relation. Additionally, when overriding this method it is usually necessary to override hashCode to ensure that objects which are "equal" (o1.equals(o2) returns true) hash to the same scala.Int. (o1.hashCode.equals(o2.hashCode)).

Calculates a hash code value for the object.

The default hashing algorithm is platform dependent.

Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)) yet not be equal (o1.equals(o2) returns false). A degenerate implementation could always return 0. However, it is required that if two objects are equal (o1.equals(o2) returns true) that they have identical hash codes (o1.hashCode.equals(o2.hashCode)). Therefore, when overriding this method, be sure to verify that the behavior is consistent with the equals method.

Returns a string representation of the object.

The default representation is platform dependent.