Rename FunctionBetaReduction to AsFunction

Author: nicolasstucki

docs/docs/reference/metaprogramming/macros.md

@@ -135,24 +135,24 @@ expressiveness.
 
 ### From `Expr`s to Functions and Back
 
-The `Expr` companion object contains an implicit `FunctionBetaReduction` conversion that turns a tree
+The `Expr` companion object contains an implicit `AsFunction` conversion that turns a tree
 describing a function into a function mapping trees to trees.
 ```scala
     object Expr {
       ...
-      implicit class FunctionBetaReduction[...](...) { ... }
+      implicit class AsFunction[...](...) { ... }
     }
 ```
 This decorator gives `Expr` the `apply` operation of an applicative functor, where `Expr`s
 over function types can be applied to `Expr` arguments. The definition
-of `FunctionBetaReduction(f).apply(x)` is assumed to be functionally the same as
+of `AsFunction(f).apply(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.
 
-The `FunctionBetaReduction` decorator distributes applications of `Expr` over function
+The `AsFunction` decorator distributes applications of `Expr` over function
 arrows:
 ```scala
-    FunctionBetaReduction(f).apply: Expr[S => T] => (Expr[S] => Expr[T])
+    AsFunction(_).apply: Expr[S => T] => (Expr[S] => Expr[T])
 ```
 Its dual, let’s call it `reflect`, can be defined as follows:
 ```scala

library/src-3.x/scala/quoted/Expr.scala

@@ -24,13 +24,13 @@ package quoted {
     /** Converts a tuple `(T1, ..., Tn)` to `(Expr[T1], ..., Expr[Tn])` */
     type TupleOfExpr[Tup <: Tuple] = Tuple.Map[Tup, Expr]
 
-    implicit class FunctionBetaReduction[F, Args <: Tuple, R](f: Expr[F]) given (tf: TupledFunction[F, Args => R]) {
+    implicit class AsFunction[F, Args <: Tuple, R](f: Expr[F]) given (tf: TupledFunction[F, Args => R]) {
       /** Beta-reduces the function appication. Generates the an expression only containing the body of the function */
       def apply[G] given (tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]]): G =
         tg.untupled(args => new FunctionAppliedTo[R](f, args.toArray.map(_.asInstanceOf[Expr[_]])))
     }
 
-    implicit class ContextualFunctionBetaReduction[F, Args <: Tuple, R](f: Expr[F]) given (tf: TupledFunction[F, given Args => R]) {
+    implicit class AsContextualFunction[F, Args <: Tuple, R](f: Expr[F]) given (tf: TupledFunction[F, given Args => R]) {
       /** Beta-reduces the function appication. Generates the an expression only containing the body of the function */
       def apply[G] given (tg: TupledFunction[G, TupleOfExpr[Args] => Expr[R]]): G =
         tg.untupled(args => new FunctionAppliedTo[R](f, args.toArray.map(_.asInstanceOf[Expr[_]])))