A marker trait for erased values. vals or parameters whose type extendsErased get an impliciterased modifier.

Assertion that an argument is by-name. Used for nullability checking.

Returns the string representation of argument code:

inline def logged(inline p1: Any) =  ("code: " + codeOf(p1), p1)logged(identity("foo"))// above is equivalent to:// ("code: scala.Predef.identity("foo")", identity("foo"))

The formatting of the code is not stable across version of the compiler.

Given a constant, singleton typeT, convert it to a value of the same singleton type. For example:assert(constValue[1] == 1).

Same asconstValue but returns aNone if a constant value cannot be constructed from the provided type. Otherwise returns that value wrapped inSome.

Given a tuple type(X1, ..., Xn), returns a tuple value(constValue[X1], ..., constValue[Xn]).

Used as the right hand side of a given in a trait, like this

given T = deferred

This signifies that the given will get a synthesized definition in all classes that implement the enclosing trait and that do not contain an explicit overriding definition of that given.

Use this method when you have a type, do not have a value for it but want to pattern match on it. For example, given a typeTup <: Tuple, one can pattern-match on it as follows:

type Tupinline def f = {inline erasedValue[Tup] match {  case _: EmptyTuple => ???  case _: (h *: t) => ???}}

This value can only be used in an inline match and the value cannot be used in the branches.

The error method is used to produce user-defined compile errors during inline expansion. If an inline expansion results in a call error(msgStr) the compiler produces an error message containing the given msgStr.

error("My error message")

or

inline def errorOnThisCode(inline x: Any) =  error("My error of this code: " + codeOf(x))

Checks at compiletime that the provided values is a constant after inlining and constant folding.

Usage:

inline def twice(inline n: Int): Int =  requireConst(n) // compile-time assertion that the parameter `n` is a constant  n + ntwice(1)val m: Int = ???twice(m) // error: expected a constant value but found: m

Given a tuple T, summons each of its member types and returns them in a Tuple.

Summons first given matching one of the listed cases. E.g. in

type Atrait Btype Cinline def f = {given B with { }summonFrom {  case given A => 1  case given B => 2  case given C => 3  case _ => 4}}

the returned value would be2.

Summon a given value of typeT. Usually, the argument is not passed explicitly. The summoning is delayed until the call has been fully inlined.

Used as the initializer of a mutable class or object field, like this:

type Tvar x: T = uninitialized

This signifies that the field is not initialized on its own. It is still initialized as part of the bulk initialization of the object it belongs to, which assigns zero values such asnull,0,0.0,false to all object fields.

Casts a value to beMatchable. This is needed if the value's type is an unconstrained type parameter and the value is the scrutinee of a match expression. This is normally disallowed since it violates parametricity and allows to uncover implementation details that were intended to be hidden. TheasMatchable escape hatch should be used sparingly. It's usually better to constrain the scrutinee type to beMatchable in the first place.

Attributes

Source

package.scala