Add quoted.Expr.{ofSeq, ofList}

Also
* Let `ofList` receive a `Seq`
* Remove `toExprOfSeq` and `toExprOfList`

Author: nicolasstucki

community-build/community-projects/scalatest

@@ -110,12 +110,12 @@ object Liftable {
 
   given [T: Type: Liftable] : Liftable[Seq[T]] = new Liftable[Seq[T]] {
     def toExpr(xs: Seq[T]): (given QuoteContext) => Expr[Seq[T]] =
-      xs.map(summon[Liftable[T]].toExpr).toExprOfSeq
+      Expr.ofSeq(xs.map(summon[Liftable[T]].toExpr))
   }
 
   given [T: Type: Liftable] : Liftable[List[T]] = new Liftable[List[T]] {
     def toExpr(xs: List[T]): (given QuoteContext) => Expr[List[T]] =
-      xs.map(summon[Liftable[T]].toExpr).toExprOfList
+      Expr.ofList(xs.map(summon[Liftable[T]].toExpr))
   }
 
   given [T: Type: Liftable] : Liftable[Set[T]] = new Liftable[Set[T]] {

community-build/community-projects/shapeless

@@ -5,33 +5,6 @@ package object quoted {
   implicit object ExprOps {
     def (x: T) toExpr[T: Liftable](given QuoteContext): Expr[T] = summon[Liftable[T]].toExpr(x)
 
-   /** Lifts this sequence of expressions into an expression of a sequence
-    *
-    *  Transforms a sequence of expression
-    *    `Seq(e1, e2, ...)` where `ei: Expr[T]`
-    *  to an expression equivalent to
-    *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
-    *
-    *  Usage:
-    *  ```scala
-    *  '{ List(${List(1, 2, 3).toExprOfSeq}: _*) } // equvalent to '{ List(1, 2, 3) }
-    *  ```
-    */
-    def (seq: Seq[Expr[T]]) toExprOfSeq[T](given tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
-      import qctx.tasty._
-      Repeated(seq.map(_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
-    }
-
-    /** Lifts this list of expressions into an expression of a list
-     *
-     *  Transforms a list of expression
-     *    `List(e1, e2, ...)` where `ei: Expr[T]`
-     *  to an expression equivalent to
-     *    `'{ List($e1, $e2, ...) }` typed as an `Expr[List[T]]`
-     */
-    def (list: List[Expr[T]]) toExprOfList[T](given Type[T], QuoteContext): Expr[List[T]] =
-      if (list.isEmpty) '{ Nil } else '{ List(${list.toExprOfSeq}: _*) }
-
     /** Lifts this sequence of expressions into an expression of a tuple
      *
      *  Transforms a sequence of expression
@@ -88,7 +61,7 @@ package object quoted {
         case Seq('{ $x1: $t1 }, '{ $x2: $t2 }, '{ $x3: $t3 }, '{ $x4: $t4 }, '{ $x5: $t5 }, '{ $x6: $t6 }, '{ $x7: $t7 }, '{ $x8: $t8 }, '{ $x9: $t9 }, '{ $x10: $t10 }, '{ $x11: $t11 }, '{ $x12: $t12 }, '{ $x13: $t13 }, '{ $x14: $t14 }, '{ $x15: $t15 }, '{ $x16: $t16 }, '{ $x17: $t17 }, '{ $x18: $t18 }, '{ $x19: $t19 }, '{ $x20: $t20 }, '{ $x21: $t21 }, '{ $x22: $t22 }) =>
           '{ Tuple22($x1, $x2, $x3, $x4, $x5, $x6, $x7, $x8, $x9, $x10, $x11, $x12, $x13, $x14, $x15, $x16, $x17, $x18, $x19, $x20, $x21, $x22) }
         case _ =>
-          '{ Tuple.fromIArray(IArray(${seq.toExprOfSeq}: _*)) }
+          '{ Tuple.fromIArray(IArray(${Expr.ofSeq(seq)}: _*)) }
       }
     }
 

community-build/community-projects/xml-interpolator

@@ -65,6 +65,34 @@ package quoted {
       Block(statements.map(_.unseal), expr.unseal).seal.asInstanceOf[Expr[T]]
     }
 
+    /** Lifts this sequence of expressions into an expression of a sequence
+     *
+     *  Transforms a sequence of expression
+     *    `Seq(e1, e2, ...)` where `ei: Expr[T]`
+     *  to an expression equivalent to
+     *    `'{ Seq($e1, $e2, ...) }` typed as an `Expr[Seq[T]]`
+     *
+     *  Usage:
+     *  ```scala
+     *  '{ List(${Expr.ofSeq(List(1, 2, 3))}: _*) } // equvalent to '{ List(1, 2, 3) }
+     *  ```
+     */
+    def ofSeq[T](xs: Seq[Expr[T]])(given tp: Type[T], qctx: QuoteContext): Expr[Seq[T]] = {
+      import qctx.tasty._
+      Repeated(xs.map(_.unseal).toList, tp.unseal).seal.asInstanceOf[Expr[Seq[T]]]
+    }
+
+
+    /** Lifts this list of expressions into an expression of a list
+     *
+     *  Transforms a list of expression
+     *    `List(e1, e2, ...)` where `ei: Expr[T]`
+     *  to an expression equivalent to
+     *    `'{ List($e1, $e2, ...) }` typed as an `Expr[List[T]]`
+     */
+    def  ofList[T](xs: Seq[Expr[T]])(given Type[T], QuoteContext): Expr[List[T]] =
+      if (xs.isEmpty) '{ Nil } else '{ List(${ofSeq(xs)}: _*) }
+
   }
 
 }

library/src-bootstrapped/scala/quoted/Liftable.scala

@@ -69,6 +69,6 @@ object Macro {
     }
     val parts = parts0.map { case Const(s) => s }
     dotty.internal.StringContextMacro.interpolate(parts.toList, args.toList, argsExpr, reporter) // Discard result
-    errors.result().toExprOfList
+    Expr.ofList(errors.result())
   }
 }

library/src-bootstrapped/scala/quoted/package.scala

@@ -4,6 +4,6 @@ import scala.quoted.given
 inline def foo = ${fooImpl}
 
 def fooImpl(given qctx: QuoteContext) = {
-  val res = List('{"One"}).toExprOfList
+  val res = Expr.ofList(List('{"One"}))
   res.show.toExpr
 }

library/src/scala/quoted/Expr.scala

@@ -4,6 +4,6 @@ import scala.quoted.given
 inline def foo(inline n: Int) = ${fooImpl(n)}
 
 def fooImpl(n: Int)(given qctx: QuoteContext) = {
-  val res = List.tabulate(n)(i => ("#" + i).toExpr).toExprOfList
+  val res = Expr.ofList(List.tabulate(n)(i => ("#" + i).toExpr))
   '{ ${res.show.toExpr} + "\n" + $res.toString + "\n" }
 }

tests/run-macros/f-interpolator-neg/Macros_1.scala

@@ -5,6 +5,6 @@ inline def foo = ${fooImpl}
 
 def fooImpl(given qctx: QuoteContext) = {
   import qctx.tasty._
-  val res = List('{"One"}).toExprOfList
+  val res = Expr.ofList(List('{"One"}))
   res.show.toExpr
 }