Scala 3/scala.compiletime

scala.compiletime

package scala.compiletime

Value members

Concrete methods

def byName[T](x: => T): T

Assertion that an argument is by-name.

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

Source:
package.scala
transparent inline def codeOf(arg: Any): String

Returns the string representation of argument code:

Returns the string representation of argument code:

package scala.compiletime
trait Snippet0 { self: compiletime.package$package.type =>
  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.

Note:

only inline arguments will be displayed as "code". Other values may display unintutively.

Source:
package.scala
transparent inline def constValue[T]: T

Given a constant, singleton type T, convert it to a value of the same singleton type.

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

Source:
package.scala
transparent inline def constValueOpt[T]: Option[T]

Same as constValue but returns a None if a constant value cannot be constructed from the provided type.

Same as constValue but returns a None if a constant value cannot be constructed from the provided type. Otherwise returns that value wrapped in Some.

Source:
package.scala
inline def constValueTuple[T <: Tuple]: T

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

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

Source:
package.scala
erased def erasedValue[T]: T

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 type Tup <: Tuple, one can pattern-match on it as follows:

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 type Tup <: Tuple, one can pattern-match on it as follows:

package scala.compiletime
trait Snippet0 { self: compiletime.package$package.type =>
  type Tup
  inline 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.

Source:
package.scala
inline def error(inline msg: String): Nothing

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.

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.

package scala.compiletime
trait Snippet0 { self: compiletime.package$package.type =>
  error("My error message")
}

or

package scala.compiletime
trait Snippet0 { self: compiletime.package$package.type =>
  inline def errorOnThisCode(inline x: Any) =
    error("My error of this code: " + codeOf(x))
}
Source:
package.scala
inline def requireConst(inline x: Boolean | Byte | Short | Int | Long | Float | Double | Char | String): Unit

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

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

Usage:

package scala.compiletime
trait Snippet0 { self: compiletime.package$package.type =>
  inline def twice(inline n: Int): Int =
    requireConst(n) // compile-time assertion that the parameter `n` is a constant
    n + n
  
  twice(1)
  val m: Int = ???
  twice(m) // error: expected a constant value but found: m
}
Source:
package.scala
inline def summonAll[T <: Tuple]: T

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

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

Type parameters:
T

the tuple containing the types of the values to be summoned

Returns:

the given values typed as elements of the tuple

Source:
package.scala
transparent inline def summonFrom[T](f: Nothing => T): T

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

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

package scala.compiletime
trait Snippet0 { self: compiletime.package$package.type =>
  type A
  trait B
  type C
  inline def f = {
  given B with { }
  
  summonFrom {
    case given A => 1
    case given B => 2
    case given C => 3
    case _ => 4
  }
  }
}

the returned value would be 2.

Source:
package.scala
transparent inline def summonInline[T]: T

Summon a given value of type T.

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

Type parameters:
T

the type of the value to be summoned

Returns:

the given value typed as the provided type parameter

Source:
package.scala
@compileTimeOnly("`uninitialized` can only be used as the right hand side of a mutable field definition")
def uninitialized: Nothing

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

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

scala //{ type T //} var 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 as null, 0, 0.0, false to all object fields.

Source:
package.scala

Extensions

Extensions

extension [T](x: T)
transparent inline def asMatchable: x & Matchable

Casts a value to be Matchable.

Casts a value to be Matchable. 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. The asMatchable escape hatch should be used sparingly. It's usually better to constrain the scrutinee type to be Matchable in the first place.

Source:
package.scala