Expanded and improved metaprogramming examples

Author: Dean Wampler

src/main/scala/progscala3/meta/Invariant.scala

@@ -8,7 +8,7 @@ object invariant:
   inline def apply[T](
       inline predicate: => Boolean, message: => String = "")(        // <2>
       inline block: => T): T =
-    if !ignore then
+    inline if !ignore then
       if !predicate then fail(predicate, message, block, "before")   // <3>
       val result = block
       if !predicate then fail(predicate, message, block, "after")
@@ -28,8 +28,8 @@ object invariant:
   private def failImpl[T](
       predicate: Expr[Boolean], message: Expr[String],
       block: Expr[T], beforeAfter: Expr[String])(
-      using Quotes): Expr[String] =                                  // <5>
-    '{ throw InvariantFailure(
+      using Quotes): Expr[String] =
+    '{ throw InvariantFailure(                                       // <5>
       s"""FAILURE! predicate "${${showExpr(predicate)}}" """
       + s"""failed ${$beforeAfter} evaluation of block:"""
       + s""" "${${showExpr(block)}}". Message = "${$message}". """)

src/main/scala/progscala3/meta/Invariant1.scala

@@ -12,7 +12,7 @@ object invariant1:
   inline def apply[T](                                          // <2>
       inline predicate: => Boolean)(
       inline block: => T): T =
-    if !ignore then                                             // <3>
+    inline if !ignore then                                      // <3>
       if !predicate then throw InvariantFailure("before")
       val result = block
       if !predicate then throw InvariantFailure("after")

src/main/scala/progscala3/meta/Tracer.scala

@@ -0,0 +1,40 @@
+// src/main/scala/progscala3/meta/Tracer.scala
+package progscala3.meta
+import scala.quoted.*
+
+/**
+ * A simple Logger abstraction used by tracer.
+ */
+trait Logger:
+  import java.time.Instant.now
+  def trace(message: => Any): Unit = log(s"TRACE ($now): $message")
+  // Other logging methods
+  protected def log(s: String): Unit
+
+object ConsoleLogger extends Logger:
+  protected def log(s: String): Unit = println(s)
+
+/**
+ * Implement a "tracer" that logs entry and exit points for an expression.
+ * Compare with our attempts to do this with just the codeOf method here:
+ *   src/script/scala/progscala3/meta/compiletime/CodeOf.scala
+ * In fact, this implementation doesn't fix the issue with "1 + 1 == 2" being
+ * printed as "true". Therefore, using CodeOf is simpler, although it's possible
+ * this implementation will have less byte code and runtime overhead.
+ * A real implementation would make the Logger configurable.
+ * See TryTracer.scala for an example program that uses tracer.
+ */
+object tracer:
+  inline def apply[T](inline expr: => T): T =
+    val s = traceStr(expr)
+    ConsoleLogger.trace(s"->: $s")
+    val t = expr
+    ConsoleLogger.trace(s"<-: $s")
+    t
+
+  inline def traceStr[T](inline expr: => T): String = ${ traceStrImpl('expr) }
+
+  def traceStrImpl[T](expr: Expr[T])(using Quotes): Expr[String] =
+    val code: String = expr.show
+    Expr(code)
+

src/main/scala/progscala3/meta/TryTracer.scala

@@ -0,0 +1,10 @@
+// src/main/scala/progscala3/meta/TryTracer.scala
+package progscala3.meta
+
+@main def TryTracer =
+  tracer(1 + 1 == 2)  // This still just prints as "true"
+  tracer("A string")
+  tracer {
+    val up = "Hello World!".toUpperCase
+    println(up)
+  }

src/script/scala/progscala3/meta/compiletime/CodeOf.scala

@@ -0,0 +1,39 @@
+// src/script/scala/progscala3/meta/compiletime/CodeOf.scala
+// Example mentioned in the book, but not discussed there.
+import scala.compiletime.codeOf
+import java.time.Instant.now
+
+// If you copy and paste these lines into the REPL, you'll see the
+// generated strings contain terminal color-coding!
+// Instead, use "scala .../CodeOf.scala", which will run the following
+// main:
+@main def TryCodeOf =
+  println("The following lines print the expression strings we want:")
+  println(codeOf(1 + 1 == 2))
+  println(codeOf("A string"))
+  println(codeOf {
+    val up = "Hello World!".toUpperCase
+    println(up)
+  })
+
+  // It would be great if the following trace method worked like the previous
+  // println statements. It almost works but unfortunately, despite using a
+  // by-name parameter and three inlines, the output "expr" string is computed
+  // after evaluating the expression, at least for the simpler `1 + 1 == 2` case.
+  // We have to use a macro for this to work. See the implementation of tracer
+  // (Tracer.scala) and invariant (Invariant.scala) later in the Metaprogramming
+  // chapter.
+  inline def trace[T](inline expr: => T): T =
+    inline val ce = codeOf(expr)
+    printf(s"Trace -> ($now): $ce\n")
+    val t = expr
+    printf(s"Trace <- ($now): $ce\n")
+    t
+
+  println("\nCalls to 'trace', which don't work the way we want:")
+  trace(1 + 1 == 2)
+  trace("A string")
+  trace {
+    val up = "Hello World!".toUpperCase
+    println(up)
+  }

src/script/scala/progscala3/meta/compiletime/ConstValue.scala

@@ -1,6 +1,6 @@
 // src/script/scala/progscala3/meta/compiletime/ConstValue.scala
 // Example mentioned in the book, but not discussed there.
-import scala.compiletime.{constValue, constValueOpt}
+import scala.compiletime.{constValue, constValueOpt, constValueTuple}
 
 // Verify that the types in [...] are constants. The *Opt variant won't throw
 // an exception if the expression is not a constant, but return None.
@@ -9,9 +9,9 @@ def tryInt =
   import compiletime.ops.int.*   // Scope this. import to this method
   assert(constValue[1] == 1)
   assert(constValueOpt[1] == Some(1))
-
-  assert(constValueOpt[1+2] == Some(3))
   assert(constValue[1+2] == 3)
+  assert(constValueOpt[1+2] == Some(3))
+  assert(constValueTuple[(1+2,3*4)] == (3,12))
 
 def tryBoolean =
   import compiletime.ops.boolean.*
@@ -30,6 +30,7 @@ def tryBoolean =
   assert(constValue[true   ^ false] == true)
   assert(constValue[false  ^ true]  == true)
   assert(constValue[false  ^ false] == false)
+  assert(constValueTuple[(true || false, true && false)] == (true, false))
 
 def tryString =
   import compiletime.ops.string.*
@@ -38,3 +39,5 @@ def tryString =
 
   assert(constValue["foo"+"bar"] == "foobar")
   assert(constValueOpt["foo"+"bar"] == Some("foobar"))
+
+  assert(constValueTuple[("foo","bar")] == ("foo", "bar"))

src/script/scala/progscala3/meta/compiletime/SummonAll.scala

@@ -0,0 +1,9 @@
+// src/script/scala/progscala3/meta/compiletime/SummonAll.scala
+import scala.compiletime.summonAll
+
+trait C; trait D; trait E
+given a: C with {}
+given b: D with {}
+
+summonAll[C *: D *: EmptyTuple]
+summonAll[C *: D *: E *: EmptyTuple]                            // <1>

src/script/scala/progscala3/meta/compiletime/SummonFrom.scala

@@ -0,0 +1,29 @@
+// src/script/scala/progscala3/meta/compiletime/SummonFrom.scala
+import scala.compiletime.summonFrom
+
+trait A; trait B
+
+inline def trySummonFrom(label: String, expected: Int): Unit =  // <1>
+  val actual = summonFrom {
+    case given A => 1
+    case given B => 2
+    case _ => 0
+  }
+  printf("%-9s trySummonFrom(): %d =?= %d\n", label, expected, actual)
+
+def tryNone = trySummonFrom("tryNone:", 0)                      // <2>
+
+def tryA =                                                      // <3>
+  given A with {}
+  trySummonFrom("tryA:", 1)
+
+def tryB =
+  given B with {}
+  trySummonFrom("tryB:", 2)
+
+def tryAB =
+  given A with {}
+  given B with {}
+  trySummonFrom("tryAB:", 1)
+
+tryNone; tryA; tryB; tryAB