Update macros

b-studios · b-studios · commit dceb41b1213e · 2020-12-18T19:12:22.000+01:00
diff --git a/_overviews/scala3-macros/faq.md b/_overviews/scala3-macros/faq.md
@@ -13,7 +13,7 @@ All quotes containing a value of a primitive type is optimised to an `Expr.apply
 Choose one in your project and stick with a single notation to avoid confusion.
 
 ## How do I get a value out of an `Expr`?
-If the expression represents a value, you can use `.unlift`, `.unliftOrError` or `Unlifted.unapply`
+If the expression represents a value, you can use `.value`, `.valueOrError` or `Expr.unapply`
 
 ## How can I get the precise type of an `Expr`?
 We can get the precise type (`Type`) of an `Expr` using the following pattern match:
diff --git a/_overviews/scala3-macros/other-resources.md b/_overviews/scala3-macros/other-resources.md
@@ -22,7 +22,6 @@ num: 9
 * [Shapeless 3](https://github.com/dotty-staging/shapeless/tree/shapeless-3)
 * *More Coming soon*
 
-
 [contributing]: contributing
 [best-practices]: best-practices
 [compiletime]: tutorial/compiletime
@@ -33,4 +32,4 @@ num: 9
 [migration-status]: https://scalacenter.github.io/scala-3-migration-guide/docs/macros/migration-status.html
 [quotes]: tutorial/quotes
 [references]: references
-[tasty]: tutorial/tasty-reflection
+[tasty]: tutorial/reflection
diff --git a/_overviews/scala3-macros/tutorial/compiletime.md b/_overviews/scala3-macros/tutorial/compiletime.md
@@ -81,5 +81,5 @@ Summon all provides a way to summon multiple values at the same time from a tupl
 [migration-status]: https://scalacenter.github.io/scala-3-migration-guide/docs/macros/migration-status.html
 [quotes]: quotes
 [references]: ../other-resources
-[tasty]: tasty-reflection
+[tasty]: reflection
 [compiletime-api]: https://dotty.epfl.ch/api/scala/compiletime/index.html
diff --git a/_overviews/scala3-macros/tutorial/index.md b/_overviews/scala3-macros/tutorial/index.md
@@ -26,7 +26,7 @@ abstractions and offers more fine-grained control.
 
   - Macros can also be defined in terms of a more _low-level_ API of [TASTy Reflection](tasty-reflection), that allows detailed inspection of programs.
 
-> The tutorial uses the API of Scala 3.0.0-M2. The API had many small changes in this revision.
+> The tutorial uses the API of Scala 3.0.0-M3. The API had many small changes in this revision.
 
 > 🚧 We are still in the process of writing the tutorial. You can [help us improve it][contributing] 🚧
 
diff --git a/_overviews/scala3-macros/tutorial/macros.md b/_overviews/scala3-macros/tutorial/macros.md
@@ -113,7 +113,7 @@ def powerCode(
   x: Expr[Double],
   n: Expr[Int]
 )(using Quotes): Expr[Double] =
-  val value: Double = pow(x.unliftOrError, n.unliftOrError)
+  val value: Double = pow(x.valueOrError, n.valueOrError)
   Expr(value)
 ```
 Here, the `pow` operation is a simple Scala function that computes the value of `xⁿ`.
@@ -126,21 +126,21 @@ Let's first look at `Expr.apply(value)`. Given a value of type `T`, this call wi
 The argument value to `Expr` is computed at compile-time, at runtime we only need to instantiate this value.
 
 Creating expressions from values works for all _primitive types_, _tuples_ of any arity, `Class`, `Array`, `Seq`, `Set`, `List`, `Map`, `Option`, `Either`, `BigInt`, `BigDecimal`, `StringContext`.
-Other types can also work if a `Liftable` is implemented for it, we will [see this later][quotes].
+Other types can also work if a `ToExpr` is implemented for it, we will [see this later][quotes].
 
 
 ### Extracting Values from Expressions
 
-The second method we use in the implementation of `powerCode` is `Expr[T].unliftOrError`, which has an effect opposite to `Expr.apply`.
+The second method we use in the implementation of `powerCode` is `Expr[T].valueOrError`, which has an effect opposite to `Expr.apply`.
 It attempts to extract a value of type `T` from an expression of type `Expr[T]`.
 This can only succeed, if the expression directly contains the code of a value, otherwise, it will throw an exception that stops the macro expansion and reports that the expression did not correspond to a value.
 
-Instead of `unliftOrError`, we could also use the `unlift` operation, which will return an `Option`.
+Instead of `valueOrError`, we could also use the `value` operation, which will return an `Option`.
 This way we can report the error with a custom error message.
 
 ```scala
   ...
-  (x.unlift, n.unlift) match
+  (x.value, n.value) match
     case (Some(base), Some(exponent)) =>
       pow(base, exponent)
     case (Some(_), _) =>
@@ -149,18 +149,18 @@ This way we can report the error with a custom error message.
       report.error("Expected a known value for the base, but was " + x.show, x)
 ```
 
-Alternatively, we can also use the `Unlifted` extractor
+Alternatively, we can also use the `Expr.unapply` extractor
 
 ```scala
   ...
   (x, n) match
-    case (Unlifted(base), Unlifted(exponent)) =>
+    case (Expr(base), Expr(exponent)) =>
       pow(base, exponent)
-    case (Unlifted(_), _) => ...
+    case (Expr(_), _) => ...
     case _ => ...
 ```
-The operations `unlift`, `unliftOrError`, and `Unlifted` will work for all _primitive types_, _tuples_ of any arity, `Option`, `Seq`, `Set`, `Map`, `Either` and `StringContext`.
-Other types can also work if an `Unliftable` is implemented for it, we will [see this later][quotes].
+The operations `value`, `valueOrError`, and `Expr.unapply` will work for all _primitive types_, _tuples_ of any arity, `Option`, `Seq`, `Set`, `Map`, `Either` and `StringContext`.
+Other types can also work if an `FromExpr` is implemented for it, we will [see this later][quotes].
 
 
 ### Showing Expressions
@@ -194,7 +194,7 @@ inline def sumNow(inline nums: Int*): Int =
 def sumCode(nums: Expr[Seq[Int]])(using Quotes): Expr[Int] =
   nums match
     case  Varargs(numberExprs) => // numberExprs: Seq[Expr[Int]]
-      val numbers: Seq[Int] = numberExprs.map(_.unliftOrError)
+      val numbers: Seq[Int] = numberExprs.map(_.valueOrError)
       Expr(numbers.sum)
     case _ => report.error(
       "Expected explicit argument" +
@@ -242,7 +242,7 @@ inline def test(inline ignore: Boolean, computation: => Unit): Boolean =
   ${ testCode('ignore, 'computation) }
 
 def testCode(ignore: Expr[Boolean], computation: Expr[Unit])(using Quotes) =
-  if ignore.unliftOrError then Expr(false)
+  if ignore.valueOrError then Expr(false)
   else Expr.block(List(computation), Expr(true))
 ```
 
@@ -252,10 +252,10 @@ The macro call `test(false, EXPRESSION)` will generate `{ EXPRESSION; true}`, wh
 ### Simple Matching
 
 The method `Expr.matches` can be used to check if one expression is equal to another.
-With this method we could implement an `unlift` operation for `Expr[Boolean]` as follows.
+With this method we could implement an `value` operation for `Expr[Boolean]` as follows.
 
 ```scala
-def unlift(boolExpr: Expr[Boolean]): Option[Boolean] =
+def value(boolExpr: Expr[Boolean]): Option[Boolean] =
   if boolExpr.matches(Expr(true)) then Some(true)
   else if boolExpr.matches(Expr(false)) then Some(false)
   else None
@@ -271,7 +271,6 @@ For example `'{ ${expr}; true }` will generate an `Expr[Int]` equivalent to `Exp
 The subsequent section on [Quoted Code][quotes] presents quotes in more detail.
 
 
-
 [best-practices]: ../best-practices
 [compiletime]: compiletime
 [faq]: ../faq
@@ -280,4 +279,4 @@ The subsequent section on [Quoted Code][quotes] presents quotes in more detail.
 [migration-status]: https://scalacenter.github.io/scala-3-migration-guide/docs/macros/migration-status.html
 [quotes]: quotes
 [references]: ../other-resources
-[tasty]: tasty-reflection
+[tasty]: reflection
diff --git a/_overviews/scala3-macros/tutorial/quotes.md b/_overviews/scala3-macros/tutorial/quotes.md
@@ -105,17 +105,17 @@ In some cases, we will not know statically the type within the `Type` and will n
 When do we need this extra `Type` parameter?
 * When a type is abstract and it is used in a level that is larger than the current level.
 
-When you add a `Type` contextual parameter to a method you will either get it from another context parameter or implicitly with a call to `Type.apply`.
+When you add a `Type` contextual parameter to a method you will either get it from another context parameter or implicitly with a call to `Type.of`.
 ```scala
 evalAndUse(Expr(3))
 // is equivalent to
-evalAndUse[Int](Expr(3))(using Type[Int])
+evalAndUse[Int](Expr(3))(using Type.of[Int])
 ```
-As you may have guessed, not every type is can be used in this `Type[..]` out of the box.
+As you may have guessed, not every type is can be used in this `Type.of[..]` out of the box.
 We cannot recover abstract types that have already been erased.
 ```scala
 def evalAndUse[T](x: Expr[T])(using Quotes) =
-  given Type[T] = Type[T] // error
+  given Type[T] = Type.of[T] // error
   '{
     val x2: T = $x
     ... // use x2
@@ -129,32 +129,32 @@ Good code should only add `Type` to the context parameters and never use them ex
 Explicit use is useful while debugging at the cost of conciseness and clarity.
 
 
-## Liftables
-The `Expr.apply` method uses intances of `Liftable` to perform the lifting.
+## ToExpr
+The `Expr.apply` method uses intances of `ToExpr` to generate an expression that will create a copy of the value.
 ```scala
 object Expr:
-  def apply[T](x: T)(using Quotes, Liftable[T]): Expr[T] =
-    summon[Liftable[T]].toExpr(x)
+  def apply[T](x: T)(using Quotes, ToExpr[T]): Expr[T] =
+    summon[ToExpr[T]].apply(x)
 ```
 
-`Liftable` is defined as follows:
+`ToExpr` is defined as follows:
 ```scala
-trait Liftable[T]:
-  def toExpr(x: T): Quotes ?=> Expr[T]
+trait ToExpr[T]:
+  def apply(x: T)(using Quotes): Expr[T]
 ```
 
-The `toExpr` method will take a value `T` and generate code that will construct a copy of this value at runtime.
+The `ToExpr.apply` method will take a value `T` and generate code that will construct a copy of this value at runtime.
 
-We can define our own `Liftable`s like:
+We can define our own `ToExpr`s like:
 ```scala
-given Liftable[Boolean] = new Liftable[Boolean] {
-  def toExpr(x: Boolean) =
+given ToExpr[Boolean] with {
+  def apply(x: Boolean)(using Quotes) =
     if x then '{true}
     else '{false}
 }
 
-given Liftable[StringContext] = new Liftable[StringContext] {
-  def toExpr(x: StringContext) =
+given ToExpr[StringContext] with {
+  def apply(x: StringContext)(using Quotes) =
     val parts = Varargs(stringContext.parts.map(Expr(_)))
     '{ StringContext($parts: _*) }
 }
@@ -251,53 +251,53 @@ case ...
 
 *Coming soon*
 
-## Unliftables
+## FromExpr
 
-The `Expr.unlift`, `Expr.unlift.orError` `Unlifted.unapply` method uses intances of `Unliftable` to perform the unlifting.
+The `Expr.value`, `Expr.valueOrError` `Expr.unapply` method uses intances of `FromExpr` to to extract the value if possible.
 ```scala
 extension [T](expr: Expr[T]):
-  def unlift(using Quotes)(using unlift: Unliftable[T]): Option[T] =
-    unlift(expr)
+  def value(using Quotes)(using fromExpr: FromExpr[T]): Option[T] =
+    fromExpr.unapply(expr)
 
-  def unliftOrError(using Quotes)(using unlift: Unliftable[T]): T =
-    unlift(expr).getOrElse(eport.throwError("...", expr))
+  def valueOrError(using Quotes)(using fromExpr: FromExpr[T]): T =
+    fromExpr.unapply(expr).getOrElse(eport.throwError("...", expr))
 end extension
 
-object Unlifted:
-  def unapply[T](expr: Expr[T])(using Quotes)(using unlift: Unliftable[T]): Option[T] =
-    unlift(expr)
+object Expr:
+  def unapply[T](expr: Expr[T])(using Quotes)(using fromExpr: FromExpr[T]): Option[T] =
+    fromExpr.unapply(expr)
 ```
 
-`Unliftable` is defined as follows:
+`FromExpr` is defined as follows:
 ```scala
-trait Unliftable[T]:
-  def fromExpr(x: Expr[T])(using Quotes): Option[T]
+trait FromExpr[T]:
+  def unapply(x: Expr[T])(using Quotes): Option[T]
 ```
 
-The `toExpr` method will take a value `T` and generate code that will construct a copy of this value at runtime.
+The `FromExpr.unapply` method will take a value `T` and generate code that will construct a copy of this value at runtime.
 
-We can define our own `Uniftable`s like:
+We can define our own `FromExpr`s like:
 ```scala
-given Unliftable[Boolean] = new Unliftable[Boolean] {
-  def fromExpr(x: Expr[Boolean])(using Quotes): Option[Boolean] =
+given FromExpr[Boolean] with {
+  def unapply(x: Expr[Boolean])(using Quotes): Option[Boolean] =
     x match
       case '{ true } => Some(true)
       case '{ false } => Some(false)
       case _ => None
 }
 
-given Unliftable[StringContext] = new Unliftable[StringContext] {
-  def fromExpr(x: Expr[StringContext])(using Quotes): Option[StringContext] = x match {
-    case '{ new StringContext(${Varargs(Unlifted(args))}: _*) } => Some(StringContext(args: _*))
-    case '{     StringContext(${Varargs(Unlifted(args))}: _*) } => Some(StringContext(args: _*))
+given FromExpr[StringContext] with {
+  def unapply(x: Expr[StringContext])(using Quotes): Option[StringContext] = x match {
+    case '{ new StringContext(${Varargs(Exprs(args))}: _*) } => Some(StringContext(args: _*))
+    case '{     StringContext(${Varargs(Exprs(args))}: _*) } => Some(StringContext(args: _*))
     case _ => None
   }
 }
 ```
 Note that we handled two cases for the `StringContext`.
 As it is a `case class` it can be created with the `new StringContext` or with the `StringContext.apply` in the companion object.
 We also used the `Varargs` extractor to match the arguments of type `Expr[Seq[String]]` into a `Seq[Expr[String]]`.
-Then we used the `Unlifted` to match known constants in the `Seq[Expr[String]]` to get a `Seq[String]`.
+Then we used the `Exprs` to match known constants in the `Seq[Expr[String]]` to get a `Seq[String]`.
 
 
 ## The Quotes
diff --git a/_overviews/scala3-macros/tutorial/reflection.md b/_overviews/scala3-macros/tutorial/reflection.md
diff --git a/scala3/new-in-scala3.md b/scala3/new-in-scala3.md
@@ -126,7 +126,7 @@ If you want to learn more about meta programming in Scala 3, we invite you to ta
 [meta-inline]: {% link _overviews/scala3-macros/tutorial/inline.md %}
 [meta-compiletime]: {% link _overviews/scala3-macros/tutorial/compiletime.md %}
 [meta-quotes]: {% link _overviews/scala3-macros/tutorial/quotes.md %}
-[meta-reflection]: {% link _overviews/scala3-macros/tutorial/tasty-reflection.md %}
+[meta-reflection]: {% link _overviews/scala3-macros/tutorial/reflection.md %}
 
 [oo-explicit-null]: {{ site.scala3ref }}/other-new-features/explicit-nulls.html
 [oo-safe-init]: {{ site.scala3ref }}/other-new-features/safe-initialization.html
