Compile-Time Operations

//> using scala 3.10.0

package trailhead

import scala.compiletime.{codeOf, constValue, constValueOpt, constValueTuple, error, erasedValue}

// constValue: turn a singleton type into a value
inline def sizeOf[N <: Int]: Int = constValue[N]

// constValueOpt: Some(value) when the type is a singleton, None otherwise
inline def describe[T]: String =
  constValueOpt[T] match
    case Some(v) => s"constant $v"
    case None    => "not a constant type"

// constValueTuple: a tuple type of singletons to a tuple of values
type Labels = ("name", "lengthKm", "ascentM")

// erasedValue: a dummy value of type T, only usable for matching on its type
inline def kindOf[T]: String =
  inline erasedValue[T] match
    case _: Int    => "int"
    case _: String => "string"
    case _: (a, b) => "pair"
    case _         => "other"

// error: a custom compile-time error
inline def alpine(inline grade: Int): Int =
  inline if grade < 1 || grade > 6 then error("Alpine grade must be between 1 and 6")
  else grade

// codeOf: the source text of an argument
inline def show(inline expr: Any): String = codeOf(expr)

@main def run(): Unit =
  println(sizeOf[42])
  println(describe["summit"])
  println(describe[String])
  println(constValueTuple[Labels])
  println(kindOf[Int])
  println(kindOf[(Int, String)])
  println(kindOf[List[Int]])
  println(alpine(4))
  println(show(1 + 2 * 3))
  println(show(List(1, 2).map(_ + 1)))

42
constant summit
not a constant type
(name,lengthKm,ascentM)
int
pair
other
4
7
List.apply[Int]([1,2 : Int]*).map[Int]((_$1: Int) => _$1 + 1)

import scala.compiletime.constValue
inline def sizeOf[N <: Int]: Int = constValue[N]
@main def run(): Unit = println(sizeOf[Int])

-- [E182] Type Error: d2.scala:4:39
4 |@main def run(): Unit = println(sizeOf[Int])
  |                                       ^^^
  |                        Int is not a constant type; cannot take constValue

//> using scala 3.10.0
import scala.compiletime.error
inline def alpine(inline grade: Int): Int =
  inline if grade < 1 || grade > 6 then error("Alpine grade must be between 1 and 6")
  else grade
@main def run(): Unit = println(alpine(9))

-- Error: d1.scala:6:38
6 |@main def run(): Unit = println(alpine(9))
  |                                ^^^^^^^^^
  |                                Alpine grade must be between 1 and 6

//> using scala 3.10.0
import scala.compiletime.requireConst
inline def beds(inline n: Int): Int =
  requireConst(n)
  n
@main def run(args: String*): Unit =
  println(beds(4))
  val k = args.size
  println(beds(k))

-- Error: r1.scala:9:14
9 |  println(beds(k))
  |          ^^^^^^^
  |          expected a constant value but found: k
  |-----------------------------------------------------------------------------
  |Inline stack trace
  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  |This location contains code that was inlined from r1.scala:4
4 |  requireConst(n)
  |               ^

trait Show[A]:
  extension (a: A) def show: String
inline def display[A](a: A): String = summon[Show[A]].show(a)

-- [E172] Type Error: d5.scala:4:53
4 |inline def display[A](a: A): String = summon[Show[A]].show(a)
  |                                                     ^
  |No given instance of type Show[A] was found for parameter x of method summon in object Predef

-- [E172] Type Error: d3.scala:6:39
6 |@main def run(): Unit = println(display(3))
  |                                ^^^^^^^^^^
  |                             No given instance of type Show[Int] was found
  |-----------------------------------------------------------------------------
  |Inline stack trace
  |- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  |This location contains code that was inlined from d3.scala:5
5 |inline def display[A](a: A): String = summonInline[Show[A]].show(a)
  |                                      ^^^^^^^^^^^^^^^^^^^^^

//> using scala 3.10.0

package trailhead

import scala.compiletime.{constValue, summonAll, summonFrom, summonInline}
import scala.compiletime.ops.int.{+, <, >, S}
import scala.compiletime.ops.int
import scala.compiletime.ops.string
import scala.compiletime.ops.any.==
import scala.compiletime.testing.{typeChecks, typeCheckErrors}

trait Show[A]:
  extension (a: A) def show: String

object Show:
  given Show[Int]:
    extension (a: Int) def show: String = s"int $a"
  given Show[String]:
    extension (a: String) def show: String = s"text $a"

// summonInline: resolved at the call site, where the given exists
inline def display[A](a: A): String = summonInline[Show[A]].show(a)

// summonFrom: branch on whether a given exists
inline def describeIfShowable[A](a: A): String =
  summonFrom:
    case s: Show[A] => s.show(a)
    case _          => s"no Show for ${a.getClass.getSimpleName}"

// summonAll: a tuple of givens
inline def both: (Show[Int], Show[String]) = summonAll[(Show[Int], Show[String])]

// type-level arithmetic on singleton types
type Total = 12 + 30
type Beds = int.*[2, 4]
type Hut = string.+["Refuge ", "Alpina"]
type Big = 5 > 3
type Same = ("a" == "a")
type Next = S[41]

@main def run(): Unit =
  println(display(3))
  println(display("ridge"))
  println(describeIfShowable(4))
  println(describeIfShowable(2.5))
  println(both._1.show(7))
  println(constValue[Total])
  println(constValue[Beds])
  println(constValue[Hut])
  println(constValue[Big])
  println(constValue[Same])
  println(constValue[Next])
  println(typeChecks("val x: Int = \"hi\""))
  println(typeChecks("val x: Int = 1"))
  println(typeCheckErrors("val x: Int = \"hi\"").map(_.message))

int 3
text ridge
int 4
no Show for double
int 7
42
8
Refuge Alpina
true
true
42
false
true
List(Found:    ("hi" : String)
Required: Int)

//> using scala 3.10.0

package trailhead

import scala.compiletime.constValue
import scala.compiletime.ops.{int, string, any}

type Name = "Lake Path"
type NameLength = string.Length[Name]
type Gradient = int.Max[3, 9]
type Described = string.+["Grade ", any.ToString[4]]
type IsLiteral = any.IsConst[Name]
type Valid = string.Matches[Name, "[A-Z][a-z]+ [A-Z][a-z]+"]

@main def run(): Unit =
  println(constValue[NameLength])
  println(constValue[Gradient])
  println(constValue[Described])
  println(constValue[IsLiteral])
  println(constValue[Valid])

9
9
Grade 4
true
true

//> using scala 3.10.0

package trailhead

import scala.compiletime.constValue
import scala.compiletime.ops.int.+

// A route with a statically known number of legs
final case class Route[N <: Int](legs: List[String]):
  def ++[M <: Int](other: Route[M]): Route[N + M] = Route(legs ::: other.legs)
  inline def size: Int = constValue[N]

@main def run(): Unit =
  val up = Route[2](List("hut", "col"))
  val down = Route[3](List("col", "lake", "car park"))
  val loop: Route[5] = up ++ down
  println(loop.size)
  println(loop.legs)

5
List(hut, col, col, lake, car park)

-- [E007] Type Mismatch Error: o1.scala:19:24
19 |  val wrong: Route[6] = up ++ down
   |                        ^^^^^^^^^^
   |                        Found:    trailhead.Route[(5 : Int)]
   |                        Required: trailhead.Route[(6 : Int)]