Add Const.unapply(Seq) and Value.unapply(Seq)

Instead of having a special concept to extract values out of sequences,
with this change, we can take advantage of composition with `Exprs`.

The old `ConstSeq` and `ValueSeq` are deprecated to reduce the sumber of concepts in the API.

Author: nicolasstucki

docs/docs/reference/metaprogramming/macros.md

@@ -616,17 +616,15 @@ 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`: matches an expression of a literal value and returns the value.
-* `scala.quoted.Value`: matches an expression of a value and returns the value.
+* `scala.quoted.Const`: matches an expression of a literal value (or list of values) and returns the value (or list of values).
+* `scala.quoted.Value`: matches an expression of a value (or list of values) and returns the value (or list of values).
 * `scala.quoted.Exprs`: 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]]`.
-* `scala.quoted.ConstSeq`:  matches an explicit sequence of literal values and returns them.
-* `scala.quoted.ValueSeq`:  matches an explicit sequence of values and returns them.
 
 These could be used in the following way to optimize any call to `sum` that has statically known values.
 ```scala
 inline def sum(inline args: Int*): Int = ${ sumExpr('args) }
 private def sumExpr(argsExpr: Expr[Seq[Int]])(using QuoteContext): Expr[Int] = argsExpr match {
-  case ConstSeq(args) => // args is of type Seq[Int]
+  case Exprs(Const(args)) => // args is of type Seq[Int]
     Expr(args.sum) // precompute result of sum
   case Exprs(argExprs) => // argExprs is of type Seq[Expr[Int]]
     val staticSum: Int = argExprs.map {

library/src-bootstrapped/dotty/internal/StringContextMacro.scala

@@ -63,9 +63,12 @@ object StringContextMacro {
 
     def notStatic =
       qctx.throwError("Expected statically known String Context", strCtxExpr)
-    def splitParts(seq: Expr[Seq[String]]) = (seq, seq) match {
-      case (Exprs(p1), ConstSeq(p2)) => (p1.toList, p2.toList)
-      case (_, _) => notStatic
+    def splitParts(seq: Expr[Seq[String]]) = seq match {
+      case Exprs(p1) =>
+        p1 match
+          case Const(p2) => (p1.toList, p2.toList)
+          case _ => notStatic
+      case _ => notStatic
     }
     val (partsExpr, parts) = strCtxExpr match {
       case '{ StringContext($parts: _*) } => splitParts(parts)

library/src/scala/quoted/Const.scala

@@ -1,18 +1,19 @@
 package scala.quoted
 
-/** Matches expressions containing literal constant values and extracts the value.
- *  It may match expressions of type Boolean, Byte, Short, Int, Long,
- *  Float, Double, Char, String, ClassTag, scala.Symbol, Null and Unit.
- *
- *  Usage:
- *  ```
- *  (x: Expr[B]) match {
- *    case Const(value: B) => ...
- *  }
- *  ```
- */
+/** MLiteral constant values */
 object Const {
 
+  /** Matches expressions containing literal constant values and extracts the value.
+   *  It may match expressions of type Boolean, Byte, Short, Int, Long,
+   *  Float, Double, Char, String, ClassTag, scala.Symbol, Null and Unit.
+   *
+   *  Usage:
+   *  ```
+   *  (x: Expr[B]) match {
+   *    case Const(value: B) => ...
+   *  }
+   *  ```
+   */
   def unapply[T](expr: Expr[T])(using qctx: QuoteContext): Option[T] = {
     import qctx.tasty.{_, given _}
     def rec(tree: Term): Option[T] = tree match {
@@ -25,4 +26,24 @@ object Const {
     rec(expr.unseal)
   }
 
+  /** 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]])(usingusing QuoteContext): Expr[Int] = argsExpr match
+   *    case Exprs(Const(args)) =>
+   *      // args: Seq[Int]
+   *      ...
+   *  }
+   *  ```
+   */
+  def unapply[T](exprs: Seq[Expr[T]])(using qctx: QuoteContext): Option[Seq[T]] =
+    exprs.foldRight(Option(List.empty[T])) { (elem, acc) =>
+      (elem, acc) match {
+        case (Const(value), Some(lst)) => Some(value :: lst)
+        case (_, _) => None
+      }
+    }
+
 }

library/src/scala/quoted/Value.scala

@@ -15,4 +15,23 @@ object Value {
   def unapply[T](expr: Expr[T])(using valueOf: ValueOfExpr[T], qxtc: QuoteContext): Option[T] =
     valueOf(expr)
 
+  /** 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 Exprs(Value(args)) =>
+   *      // args: Seq[Int]
+   *      ...
+   *  }
+   *  ```
+   */
+  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 (_, _) => None
+      }
+    }
 }

library/src/scala/quoted/ValueOfExpr.scala

@@ -42,8 +42,8 @@ object ValueOfExpr {
 
   given StringContext_delegate as ValueOfExpr[StringContext] = new {
     def apply(x: Expr[StringContext])(using qctx: QuoteContext): Option[StringContext] = x match {
-      case '{ new StringContext(${ConstSeq(args)}: _*) } => Some(StringContext(args: _*))
-      case '{     StringContext(${ConstSeq(args)}: _*) } => Some(StringContext(args: _*))
+      case '{ new StringContext(${Exprs(Const(args))}: _*) } => Some(StringContext(args: _*))
+      case '{     StringContext(${Exprs(Const(args))}: _*) } => Some(StringContext(args: _*))
       case _ => None
     }
     override def toString(): String = "scala.quoted.ValueOfExpr.Tuple1_delegate"
@@ -270,9 +270,9 @@ object ValueOfExpr {
 
   given Seq_delegate[T](using Type[T], ValueOfExpr[T]) as ValueOfExpr[Seq[T]] = new {
     def apply(x: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[T]] = x match {
-      case ValueSeq(elems) => Some(elems)
-      case '{ scala.collection.Seq[T](${ValueSeq(elems)}: _*) } => Some(elems)
-      case '{ scala.collection.immutable.Seq[T](${ValueSeq(elems)}: _*) } => Some(elems)
+      case Exprs(Value(elems)) => Some(elems)
+      case '{ scala.collection.Seq[T](${Exprs(Value(elems))}: _*) } => Some(elems)
+      case '{ scala.collection.immutable.Seq[T](${Exprs(Value(elems))}: _*) } => Some(elems)
       case _ => None
     }
     override def toString(): String = "scala.quoted.ValueOfExpr.Seq_delegate"

library/src/scala/quoted/ConstSeq.scala renamed to library/src/scala/quoted/matching/ConstSeq.scala

@@ -1,4 +1,5 @@
 package scala.quoted
+package matching
 
 /** Literal sequence of literal constant value expressions */
 object ConstSeq {
@@ -15,15 +16,11 @@ object ConstSeq {
    *  }
    *  ```
    */
-  def unapply[T](expr: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[T]] = expr match {
-    case Exprs(elems) =>
-      elems.foldRight(Option(List.empty[T])) { (elem, acc) =>
-        (elem, acc) match {
-          case (Const(value), Some(lst)) => Some(value :: lst)
-          case (_, _) => None
-        }
-      }
-    case _ => None
-  }
+  @deprecated("use scala.quoted.Exprs(scala.quoted.Const(_)) instead", "0.23.0")
+  def unapply[T](expr: Expr[Seq[T]])(using qctx: QuoteContext): Option[Seq[T]] =
+    import scala.quoted.Const
+    expr match
+      case Exprs(Const(elems)) => Some(elems)
+      case _ => None
 
 }

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

@@ -1,4 +1,5 @@
 package scala.quoted
+package matching
 
 /** Value sequence of value expressions */
 object ValueSeq {
@@ -15,15 +16,11 @@ object ValueSeq {
    *  }
    *  ```
    */
-  def unapply[T](expr: Expr[Seq[T]])(using valueOf: ValueOfExpr[T], qctx: QuoteContext): Option[Seq[T]] = expr match {
-    case Exprs(elems) =>
-      elems.foldRight(Option(List.empty[T])) { (elem, acc) =>
-        (elem, acc) match {
-          case (Value(value), Some(lst)) => Some(value :: lst)
-          case (_, _) => None
-        }
-      }
-    case _ => None
-  }
+  @deprecated("use scala.quoted.Exprs(scala.quoted.Value(_)) 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 Exprs(Value(elems)) => Some(elems)
+      case _ => None
 
 }

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

@@ -17,9 +17,6 @@ package object matching {
   @deprecated("use scala.quoted.Const instead", "0.23.0")
   val Const: quoted.Const.type = quoted.Const
 
-  @deprecated("use scala.quoted.ConstSeq instead", "0.23.0")
-  val ConstSeq: quoted.ConstSeq.type = quoted.ConstSeq
-
   @deprecated("use scala.quoted.Exprs instead", "0.23.0")
   val ExprSeq: quoted.Exprs.type = quoted.Exprs
 
@@ -32,7 +29,4 @@ package object matching {
   @deprecated("use scala.quoted.ValueOfExpr instead", "0.23.0")
   val ValueOfExpr: quoted.ValueOfExpr.type = quoted.ValueOfExpr
 
-  @deprecated("use scala.quoted.ValueSeq instead", "0.23.0")
-  val ValueSeq: quoted.ValueSeq.type = quoted.ValueSeq
-
 }

tests/run-macros/quote-matcher-string-interpolator-3/quoted_1.scala

@@ -8,7 +8,7 @@ object Macros {
 
   private def impl(self: Expr[StringContext], args: Expr[Seq[String]])(using QuoteContext): Expr[String] = {
     self match {
-      case '{ StringContext(${ConstSeq(parts)}: _*) } =>
+      case '{ StringContext(${Exprs(Const(parts))}: _*) } =>
         val upprerParts: List[String] = parts.toList.map(_.toUpperCase)
         val upprerPartsExpr: Expr[List[String]] = Expr.ofList(upprerParts.map(Expr(_)))
         '{ StringContext($upprerPartsExpr: _*).s($args: _*) }

tests/run-macros/quoted-matching-docs/Macro_1.scala

@@ -12,7 +12,7 @@ private def sumExprShow(argsExpr: Expr[Seq[Int]]) (using QuoteContext): Expr[Str
 private def sumExpr(argsExpr: Expr[Seq[Int]])(using qctx: QuoteContext) : Expr[Int] = {
   import qctx.tasty.{given _, _}
   UnsafeExpr.underlyingArgument(argsExpr) match {
-    case ConstSeq(args) => // args is of type Seq[Int]
+    case Exprs(Const(args)) => // args is of type Seq[Int]
       Expr(args.sum) // precompute result of sum
     case Exprs(argExprs) => // argExprs is of type Seq[Expr[Int]]
       val staticSum: Int = argExprs.map {