Rename Expr.reduce to Expr.betaReduce

Author: nicolasstucki

community-build/community-projects/xml-interpolator

@@ -135,20 +135,20 @@ expressiveness.
 
 ### From `Expr`s to Functions and Back
 
-The `Expr` companion object contains a `reduce` conversion that turns a tree
+The `Expr` companion object contains a `betaReduce` conversion that turns a tree
 describing a function into a function mapping trees to trees.
 ```scala
 object Expr {
   ...
-  def reduce[...](...)(...): ... =
+  def betaReduce[...](...)(...): ... = ...
 }
 ```
-The definition of `Expr.reduce(f)(x)` is assumed to be functionally the same as
+The definition of `Expr.betaReduce(f)(x)` is assumed to be functionally the same as
 `'{($f)($x)}`, however it should optimize this call by returning the
 result of beta-reducing `f(x)` if `f` is a known lambda expression.
-`Expr.reduce` distributes applications of `Expr` over function arrows:
+`Expr.betaReduce` distributes applications of `Expr` over function arrows:
 ```scala
-Expr.reduce(_): Expr[(T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
+Expr.betaReduce(_): Expr[(T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
 ```
 Its dual, let’s call it `reflect`, can be defined as follows:
 ```scala

docs/docs/reference/metaprogramming/macros.md

@@ -28,29 +28,29 @@ package quoted {
     /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */
     type TupleOfExpr[Tup <: Tuple] = Tuple.Map[Tup, [X] =>> (given QuoteContext) => Expr[X]]
 
-    /** `Expr.reduce(f)(x1, ..., xn)` is functionally the same as `'{($f)($x1, ..., $xn)}`, however it optimizes this call 
+    /** `Expr.betaReduce(f)(x1, ..., xn)` is functionally the same as `'{($f)($x1, ..., $xn)}`, however it optimizes this call
      *   by returning the result of beta-reducing `f(x1, ..., xn)` if `f` is a known lambda expression.
      *
-     *  `Expr.reduce` distributes applications of `Expr` over function arrows
+     *  `Expr.betaReduce` distributes applications of `Expr` over function arrows
      *   ```scala
-     *   Expr.reduce(_): Expr[(T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
+     *   Expr.betaReduce(_): Expr[(T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
      *   ```
      */
-    def reduce[F, Args <: Tuple, R, G](f: Expr[F])(given tf: TupledFunction[F, Args => R], tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]], qctx: QuoteContext): G = {
+    def betaReduce[F, Args <: Tuple, R, G](f: Expr[F])(given tf: TupledFunction[F, Args => R], tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]], qctx: QuoteContext): G = {
       import qctx.tasty._
       tg.untupled(args => qctx.tasty.internal.betaReduce(f.unseal, args.toArray.toList.map(_.asInstanceOf[QuoteContext => Expr[_]](qctx).unseal)).seal.asInstanceOf[Expr[R]])
     }
 
-    /** `Expr.reduceGiven(f)(x1, ..., xn)` is functionally the same as `'{($f)(given $x1, ..., $xn)}`, however it optimizes this call 
+    /** `Expr.betaReduceGiven(f)(x1, ..., xn)` is functionally the same as `'{($f)(given $x1, ..., $xn)}`, however it optimizes this call
      *   by returning the result of beta-reducing `f(given x1, ..., xn)` if `f` is a known lambda expression.
      *
-     *  `Expr.reduceGiven` distributes applications of `Expr` over function arrows
+     *  `Expr.betaReduceGiven` distributes applications of `Expr` over function arrows
      *   ```scala
-     *   Expr.reduceGiven(_): Expr[(given T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
+     *   Expr.betaReduceGiven(_): Expr[(given T1, ..., Tn) => R] => ((Expr[T1], ..., Expr[Tn]) => Expr[R])
      *   ```
-     *  Note: The 
+     *  Note: The
      */
-    def reduceGiven[F, Args <: Tuple, R, G](f: Expr[F])(given tf: TupledFunction[F, (given Args) => R], tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]], qctx: QuoteContext): G = {
+    def betaReduceGiven[F, Args <: Tuple, R, G](f: Expr[F])(given tf: TupledFunction[F, (given Args) => R], tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]], qctx: QuoteContext): G = {
       import qctx.tasty._
       tg.untupled(args => qctx.tasty.internal.betaReduce(f.unseal, args.toArray.toList.map(_.asInstanceOf[QuoteContext => Expr[_]](qctx).unseal)).seal.asInstanceOf[Expr[R]])
     }

library/src/scala/quoted/Expr.scala

@@ -1,6 +1,6 @@
 import scala.quoted._
 
-def testImpl(f: Expr[(Int, Int) => Int])(given QuoteContext): Expr[Int] = Expr.reduce(f)('{1}, '{2})
+def testImpl(f: Expr[(Int, Int) => Int])(given QuoteContext): Expr[Int] = Expr.betaReduce(f)('{1}, '{2})
 
 inline def test(f: (Int, Int) => Int) = ${
   testImpl('f)

tests/pos/i6783.scala

@@ -24,7 +24,7 @@ object Optional {
   // FIXME fix issue #5097 and enable private
   /*private*/ def mapImpl[A >: Null : Type, B >: Null : Type](opt: Expr[Optional[A]], f: Expr[A => B])(given QuoteContext): Expr[Optional[B]] = '{
     if ($opt.isEmpty) new Optional(null)
-    else new Optional(${Expr.reduce(f)('{$opt.value})})
+    else new Optional(${Expr.betaReduce(f)('{$opt.value})})
   }
 
 }

tests/run-macros/gestalt-optional-staging/Macro_1.scala

@@ -15,7 +15,7 @@ object Macros {
         for (j <- new UnrolledRange(0, unrollSize)) '{
           val index = i + $j
           val element = ($seq)(index)
-          ${ Expr.reduce(f)('element) } // or `($f)(element)` if `f` should not be inlined
+          ${ Expr.betaReduce(f)('element) } // or `($f)(element)` if `f` should not be inlined
         }
       }
       i += ${unrollSize}

tests/run-macros/i4734/Macro_1.scala

@@ -17,7 +17,7 @@ object Macro {
       ${
         for (j <- new UnrolledRange(0, unrollSize)) '{
           val element = ($seq)(i + ${j})
-          ${Expr.reduce(f)('element)} // or `($f)(element)` if `f` should not be inlined
+          ${Expr.betaReduce(f)('element)} // or `($f)(element)` if `f` should not be inlined
         }
       }
       i += ${unrollSize}

tests/run-macros/i4735/Macro_1.scala

@@ -15,5 +15,5 @@ def mcrProxy(expr: Expr[Boolean])(given QuoteContext): Expr[Unit] = {
 def mcrImpl[T](func: Expr[Seq[Box[T]] => Unit], expr: Expr[T])(given ctx: QuoteContext, tt: Type[T]): Expr[Unit] = {
   import ctx.tasty._
   val arg = Expr.ofSeq(Seq('{(Box($expr))}))
-  Expr.reduce(func)(arg)
+  Expr.betaReduce(func)(arg)
 }

tests/run-macros/i7008/macro_1.scala

@@ -12,11 +12,11 @@ object Macros {
       var i = $start
       val j = $end
       while (i < j) {
-        ${Expr.reduce(f)('i)}
+        ${Expr.betaReduce(f)('i)}
         i += 1
       }
       while {
-        ${Expr.reduce(f)('i)}
+        ${Expr.betaReduce(f)('i)}
         i += 1
         i < j
       } do ()

tests/run-macros/quote-inline-function/quoted_1.scala

@@ -72,7 +72,7 @@ object StringNum extends Symantics[String] {
   def value(x: Int)(given QuoteContext): Expr[String] = Expr(x.toString)
   def plus(x: Expr[String], y: Expr[String])(given QuoteContext): Expr[String] = '{ s"${$x} + ${$y}" } // '{ x + " + " + y }
   def times(x: Expr[String], y: Expr[String])(given QuoteContext): Expr[String] = '{ s"${$x} * ${$y}" }
-  def app(f: Expr[String => String], x: Expr[String])(given QuoteContext): Expr[String] = Expr.reduce(f)(x)
+  def app(f: Expr[String => String], x: Expr[String])(given QuoteContext): Expr[String] = Expr.betaReduce(f)(x)
   def lam(body: Expr[String] => Expr[String])(given QuoteContext): Expr[String => String] = '{ (x: String) => ${body('x)} }
 }