Add quoted.Exprs and move Value(s) into Expr(s)

docs/docs/reference/metaprogramming/macros.md

@@ -617,7 +617,7 @@ It is possible to deconstruct or extract values out of `Expr` using pattern matc
 `scala.quoted` contains objects that can help extracting values from `Expr`.
 
 * `scala.quoted.Const`/`scala.quoted.Consts`: matches an expression of a literal value (or list of values) and returns the value (or list of values).
-* `scala.quoted.Value`/`scala.quoted.Values`: matches an expression of a value (or list of values) and returns the value (or list of values).
+* `scala.quoted.Expr`/`scala.quoted.Exprs`: matches an expression of a value (or list of values) and returns the value (or list of values).
 * `scala.quoted.Varargs`: matches an explicit sequence of expresions and returns them. These sequences are useful to get individual `Expr[T]` out of a varargs expression of type `Expr[Seq[T]]`.
 
 These could be used in the following way to optimize any call to `sum` that has statically known values.

library/src/scala/quoted/Expr.scala

@@ -102,6 +102,18 @@ object Expr {
   /** Lift a value into an expression containing the construction of that value */
   def apply[T](x: T)(using qctx: QuoteContext, lift: Liftable[T]): Expr[T] = lift.toExpr(x)
 
+  /** Matches expressions containing values and extracts the value.
+   *
+   *  Usage:
+   *  ```
+   *  (x: Expr[B]) match {
+   *    case Expr(value) => ... // value: B
+   *  }
+   *  ```
+   */
+   def unapply[T](expr: Expr[T])(using valueOf: ValueOfExpr[T], qxtc: QuoteContext): Option[T] =
+    valueOf(expr)
+
   /** Lifts this sequence of expressions into an expression of a sequence
    *
    *  Transforms a sequence of expression

library/src/scala/quoted/Values.scala → library/src/scala/quoted/Exprs.scala

@@ -1,15 +1,19 @@
 package scala.quoted
 
-/** Value expressions */
-object Values {
+/** Sequences of expressions */
+object Exprs {
+
+  /** Lift a sequence of values into a sequense of expressions containing the construction of each value */
+  def apply[T](xs: Seq[T])(using lift: Liftable[T], qctx: QuoteContext): Seq[Expr[T]] =
+    xs.map(x => Expr(x))
 
   /** Matches literal sequence of literal constant value expressions and return a sequence of values.
    *
    *  Usage:
    *  ```scala
    *  inline def sum(args: Int*): Int = ${ sumExpr('args) }
    *  def sumExpr(argsExpr: Expr[Seq[Int]])(using QuoteContext): Expr[Int] = argsExpr match
-   *    case Varargs(Values(args)) =>
+   *    case Varargs(Exprs(args)) =>
    *      // args: Seq[Int]
    *      ...
    *  }
@@ -18,8 +22,9 @@ object Values {
   def unapply[T](exprs: Seq[Expr[T]])(using valueOf: ValueOfExpr[T], qctx: QuoteContext): Option[Seq[T]] =
     exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
       (elem, acc) match {
-        case (Value(value), Some(lst)) => Some(value :: lst)
+        case (Expr(value), Some(lst)) => Some(value :: lst)
         case (_, _) => None
       }
     }
+
 }

library/src/scala/quoted/matching/ValueSeq.scala

@@ -16,11 +16,11 @@ object ValueSeq {
    *  }
    *  ```
    */
-  @deprecated("use scala.quoted.Varargs(scala.quoted.Value(_)) instead", "0.23.0")
+  @deprecated("use scala.quoted.Varargs(scala.quoted.Exprs(_)) instead", "0.23.0")
   def unapply[T](expr: Expr[Seq[T]])(using valueOf: ValueOfExpr[T], qctx: QuoteContext): Option[Seq[T]] =
     import scala.quoted.Const
     expr match
-      case Varargs(Values(elems)) => Some(elems)
+      case Varargs(Exprs(elems)) => Some(elems)
       case _ => None
 
 }

library/src/scala/quoted/matching/package.scala

@@ -23,8 +23,8 @@ package object matching {
   @deprecated("use scala.quoted.Lambda instead", "0.23.0")
   val Lambda: quoted.Lambda.type = quoted.Lambda
 
-  @deprecated("use scala.quoted.Value instead", "0.23.0")
-  val Value: quoted.Value.type = quoted.Value
+  @deprecated("use scala.quoted.Expr instead", "0.23.0")
+  val Value: quoted.Expr.type = quoted.Expr
 
   @deprecated("use scala.quoted.ValueOfExpr instead", "0.23.0")
   val ValueOfExpr: quoted.ValueOfExpr.type = quoted.ValueOfExpr