scala

A marker trait indicating that values of type L can be compared to values of type R.

Companion object containing a few universally known CanEqual instances. CanEqual instances involving primitive types or the Null type are handled directly in the compiler (see Implicits.synthesizedCanEqual), so they are not included here.

A class for implicit values that can serve as implicit conversions. The implicit resolution algorithm will act as if there existed the additional implicit definition:

def $implicitConversion[T, U](x: T)(c: Conversion[T, U]): U = c(x)

However, the presence of this definition would slow down implicit search since its outermost type matches any pair of types. Therefore, implicit search contains a special case in Implicits#discardForView which emulates the conversion in a more efficient way.

Note that this is a SAM class - function literals are automatically converted to the Conversion values.

Also note that in bootstrapped dotty, Predef.<:< should inherit from Conversion. This would cut the number of special cases in discardForView from two to one.

The Conversion class can also be used to convert explicitly, using the convert extension method.

A tuple of 0 elements.

An immutable array. An IArray[T] has the same representation as an Array[T], but it cannot be updated. Unlike regular arrays, immutable arrays are covariant.

Separate from NamedTuple object so that we can match on the opaque type NamedTuple.

Tuple of arbitrary non-zero arity

Marker trait for polymorphic function types.

This trait can only be refined with a polymorphic method, as long as that method is called apply, e.g.: PolyFunction { def apply[T_1, ..., T_M](x_1: P_1, ..., x_N: P_N): R } Exactly one term argument list is expected. The term argument list may be contextual.

This type will be erased to FunctionN or FunctionXXL.

A marker trait for objects that support structural selection via selectDynamic and applyDynamic

Implementation classes should define, or make available as extension methods, the following two method signatures:

  def selectDynamic(name: String): Any
  def applyDynamic(name: String)(args: Any*): Any =

selectDynamic is invoked for simple selections v.m, whereas applyDynamic is invoked for selections with arguments v.m(...). If there's only one kind of selection, the method supporting the other may be omitted. The applyDynamic can also have a second parameter list of java.lang.Class arguments, i.e. it may alternatively have the signature

  def applyDynamic(name: String, paramClasses: Class[_]*)(args: Any*): Any

In this case the call will synthesize Class arguments for the erasure of all formal parameter types of the method in the structural type.

Tuple of arbitrary arity

An annotation that designates a main function

A capability class that allows to throw exception E. When used with the experimental.saferExceptions feature, a throw Ex() expression will require a given of class CanThrow[Ex] to be available.

A type class-like trait intended as a context bound for type variables. If we have [X: Precise], instances of the type variable X are inferred in precise mode. This means that singleton types and union types are not widened.

A marker trait that declares that all inheriting classes are "pure" in the sense that their values retain no capabilities including capabilities needed to perform effects. This has formal meaning only under capture checking.

A tuple of 0 elements