From 37a8d3111b9f630555409ed65e0faa11d0d2fb77 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 00:44:53 +0200 Subject: [PATCH 01/17] Add Mirror-based derivation for ToExpr and FromExpr Adds `ToExpr.derived[T]`/`FromExpr.derived[T]` using `scala.deriving.Mirror`, so product and sum types can `derives ToExpr, FromExpr` instead of requiring hand-written instances. `FromExpr.derived` recognizes `ToExpr.derived`'s own `mirror.fromProduct(tuple)` output (via the actual `TupleN` module class, since a `Mirror`'s `MirroredElemTypes` is a `*:`-chain that ordinary implicit search can't resolve to the nominal `TupleN` instances), so deriving both on the same type round-trips. Co-Authored-By: Claude Sonnet 5 --- library/src/scala/quoted/FromExpr.scala | 58 ++++ library/src/scala/quoted/ToExpr.scala | 34 ++- .../Macro_1.scala | 267 ++++++++++++++++++ .../Test_2.scala | 32 +++ .../Macro_1.scala | 126 +++++++++ .../Test_2.scala | 23 ++ 6 files changed, 535 insertions(+), 5 deletions(-) create mode 100644 tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala create mode 100644 tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala create mode 100644 tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala create mode 100644 tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index 40fea5b42258..aae7a88c7691 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -1,6 +1,7 @@ package scala.quoted import language.experimental.captureChecking +import scala.annotation.{nowarn, tailrec} /** A type class for types that can convert a `quoted.Expr[T]` to a `T`. * @@ -31,6 +32,63 @@ trait FromExpr[T] { /** Default given instances of `FromExpr`. */ object FromExpr { + import scala.deriving.Mirror + + /** Derives a `FromExpr[T]` using its `Mirror`; also recognizes `ToExpr.derived`'s own + * `mirror.fromProduct(tuple)` output, so deriving both on the same type round-trips. + */ + inline def derived[T: Mirror.Of as m]: FromExpr[T] = + val elemInstances = compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExpr]].toList.asInstanceOf[List[FromExpr[Any]]] + inline m match + case given Mirror.ProductOf[T] => derivedProduct[T](elemInstances) + case given Mirror.SumOf[T] => derivedSum[T](elemInstances) + + @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] + private inline def derivedProduct[T](elemInstances: List[FromExpr[Any]])(using m: Mirror.ProductOf[T]): FromExpr[T] = new FromExpr[T]: + def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = + import quotes.reflect.* + val tpe = TypeRepr.of[T] + val sym = tpe.typeSymbol + + @tailrec def stripWrappers(t: Term): Term = t match + case Inlined(_, Nil, e) => stripWrappers(e) + case Block(Nil, e) => stripWrappers(e) + case Typed(e, _) => stripWrappers(e) + case _ => t + + // `new T(args*)` (primary ctor) or `T(args*)` (companion `apply`). + def isOwnConstructor(fun: Term): Boolean = + fun.symbol == sym.primaryConstructor + || (fun.symbol.name == "apply" && fun.symbol.owner == sym.companionModule.moduleClass) + + // defn.TupleClass does not work :/ + def tupleModuleClass = + Symbol.requiredModule(if elemInstances.isEmpty then "scala.Tuple" else s"scala.Tuple${elemInstances.length}").moduleClass + + def extractArgs(args: List[Term]): Option[T] = elemInstances.zip(args).foldRight(Option(List.empty[Any])): + case (_, None) => None + case ((fe, arg), Some(acc)) => + fe.unapply(arg.asExprOf[Any]).map(_ :: acc) + .map(vs => m.fromProduct(Tuple.fromArray(vs.toArray))) + + stripWrappers(x.asTerm) match + case Apply(fun, args) if args.length == elemInstances.length && isOwnConstructor(fun) => + extractArgs(args) + // case '{ type tuple <: Tuple; { $mirror : Mirror.ProductOf[T] }.fromProduct($tuple : tuple ) } => on x does not work :/ + case Apply(Select(recv, "fromProduct"), List(tupleArg)) if recv.tpe <:< TypeRepr.of[Mirror.ProductOf[T]] => + stripWrappers(tupleArg) match + case Apply(fun, args) if fun.symbol.name == "apply" && fun.symbol.owner == tupleModuleClass && args.length == elemInstances.length => extractArgs(args) + case _ => None + // A bare reference to a singleton (case object/enum case), not a call. TermRef for an explicit given/enum case, TypeRef (via companion) for `derives`. + case t if elemInstances.isEmpty && t.symbol == (if tpe.termSymbol.exists then tpe.termSymbol else sym.companionModule) => + Some(m.fromProduct(EmptyTuple)) + case _ => None + + private def derivedSum[T: Mirror.SumOf](elemInstances: List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: + def unapply(x: Expr[T])(using Quotes): Option[T] = + elemInstances.iterator.map(_.unapply(x.asInstanceOf[Expr[Any]])).collectFirst { case Some(v) => v.asInstanceOf[T] } + + /** Default implementation of `FromExpr[Boolean]` * - Transform `'{true}` into `Some(true)` * - Transform `'{false}` into `Some(false)` diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 17bf89a71e50..551fdce27bcd 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -1,20 +1,20 @@ package scala.quoted import language.experimental.captureChecking - +import scala.annotation.nowarn import scala.reflect.ClassTag /** A type class for types that can convert a value of `T` into `quoted.Expr[T]` - * an expression that, when evaluated, produces a value equal to the original. + * an expression that, when evaluated, produces a value equal to the original. * - * @tparam T the type of the value to be lifted into an `Expr[T]` + * @tparam T the type of the value to be lifted into an `Expr[T]` */ trait ToExpr[T] { /** Lift a value into an expression containing the construction of that value. * - * @param x the value to lift into a quoted expression - * @return an `Expr[T]` that, when evaluated, produces a value equal to `x` + * @param x the value to lift into a quoted expression + * @return an `Expr[T]` that, when evaluated, produces a value equal to `x` */ def apply(x: T)(using Quotes): Expr[T] @@ -23,8 +23,32 @@ trait ToExpr[T] { /** Default given instances of `ToExpr`. */ object ToExpr { + import scala.deriving.Mirror + import scala.quoted.* + + inline def derived[T: Mirror.Of as m]: ToExpr[T] = + type Elems = m.MirroredElemTypes + val elemInstances = compiletime.summonAll[Tuple.Map[Elems, ToExpr]].toList.asInstanceOf[List[ToExpr[Any]]] + m match + case given Mirror.ProductOf[T] => derivedProduct[T](elemInstances) + case given Mirror.SumOf[T] => derivedSum[T](elemInstances) + + @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] + private inline def derivedProduct[T: Mirror.ProductOf](elemInstances: List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: + def apply(x: T)(using Quotes): Expr[T] = + val mirrorExpr = Expr.summon[Mirror.ProductOf[T]].get + val elemVals = x.asInstanceOf[Product].productIterator.toList + val elemExprs = elemInstances.zip(elemVals).map(_.apply(_)) + val tupleExpr = Expr.ofTupleFromSeq(elemExprs) + '{ $mirrorExpr.fromProduct($tupleExpr) } + + private def derivedSum[T: Mirror.SumOf as m](elemInstances: List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: + def apply(x: T)(using Quotes): Expr[T] = elemInstances(m.ordinal(x)).apply(x).asInstanceOf[Expr[T]] // IMPORTANT Keep in sync with tests/run-staging/liftables.scala + given ValueOfToExpr: [T: {ValueOf, Type}] => ToExpr[T]: + def apply(x: T)(using Quotes): Expr[T] = '{ valueOf[T] } + /** Default implementation of `ToExpr[Boolean]`. */ given BooleanToExpr[T <: Boolean]: ToExpr[T] with { def apply(x: T)(using Quotes) = diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala new file mode 100644 index 000000000000..83067e5a4f02 --- /dev/null +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -0,0 +1,267 @@ +import scala.quoted.* + +// Product derivation: plain case class with primitive fields. Also derives `ToExpr`, so +// this doubles as the round-trip test type below. +case class Point(x: Int, y: Int) derives ToExpr, FromExpr + +// Product derivation: case class with a variety of primitive field kinds. Also derives +// `ToExpr`, to exercise the round-trip test at an arity (3) beyond the smallest cases. +case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExpr, FromExpr + +// Same shape (one Int field) as each other, but nominally distinct types: proves the +// `fromProduct` recognition branch checks the receiver is specifically `Mirror.ProductOf[T]` +// rather than accepting any same-arity `fromProduct` call (which would let a `Meters` tree +// be silently misread as a `Seconds` value, since field-level extraction alone can't catch +// the mismatch when the field types happen to coincide too). +case class Meters(value: Int) derives ToExpr, FromExpr +case class Seconds(value: Int) derives ToExpr, FromExpr + +// `Mirror.ProductOf` exists for tuple types too, so `derived` works when `T` itself is a +// tuple -- not just when a tuple shows up as the argument to some other type's +// `fromProduct` call. Named explicitly (rather than via `derives`, which isn't valid syntax +// on a type alias) to avoid shadowing/ambiguity with the library's own hand-written +// `Tuple2FromExpr`/`Tuple5FromExpr` givens when summoned generically elsewhere. +given tuple2FromExpr: FromExpr[(Int, String)] = FromExpr.derived +given tuple2ToExpr: ToExpr[(Int, String)] = ToExpr.derived +given tuple5FromExpr: FromExpr[(Int, String, Boolean, Double, Char)] = FromExpr.derived +given tuple5ToExpr: ToExpr[(Int, String, Boolean, Double, Char)] = ToExpr.derived + +// Product derivation: nested case classes, one nested inside another object's companion. +case class Address(city: String, zip: Int) derives FromExpr +object Namespace: + case class Person(name: String, address: Address) derives FromExpr + +// Three levels of nesting, to make sure recursion isn't hardcoded to depth 1-2. +case class Company(hq: Address, ceo: Namespace.Person) derives FromExpr + +// Product derivation: case object (singleton). Matches a bare reference to the module, +// not a call. Also derives `ToExpr`, for the round-trip test below. +case object Singleton derives ToExpr, FromExpr + +// Product derivation: generic case class. Just like `ToExpr`, `derives` only adds a +// `FromExpr[A]` bound (not `Type[A]`), so a generic class needs an explicit given. Also +// given a `ToExpr`, for the round-trip test below. +case class Box[A](value: A) +given boxFromExpr[A: Type: FromExpr]: FromExpr[Box[A]] = FromExpr.derived +given boxToExpr[A: Type: ToExpr]: ToExpr[Box[A]] = ToExpr.derived + +// Sum derivation: sealed hierarchy of case classes and case objects, nested inside the +// sealed trait's own companion object. Each case needs its own instance; the sum type's +// own instance just tries each case's `unapply` in turn. +// Also derives `ToExpr` on the sum type and its variants, for the round-trip test below. +sealed trait Shape derives ToExpr, FromExpr +object Shape: + case class Circle(r: Double) extends Shape derives ToExpr, FromExpr + case class Rect(w: Double, h: Double) extends Shape derives ToExpr, FromExpr + case object Origin extends Shape derives ToExpr, FromExpr + +// Sum derivation over an enum with a mix of singleton and parameterized cases (mirrors +// the equivalent test in the ToExpr suite). Each case still needs its own instance. Also +// derives `ToExpr` (on the enum and each case), for the round-trip test below -- an enum +// singleton's `Type[T]` is `TermRef`-encoded (see the fix in `FromExpr.derivedProduct`), +// distinct from a real case object's `TypeRef`-encoded module class. +enum Color derives ToExpr, FromExpr: + case Red, Green + case Custom(hex: String) + +given ToExpr[Color.Red.type] = ToExpr.derived +given ToExpr[Color.Green.type] = ToExpr.derived +given ToExpr[Color.Custom] = ToExpr.derived +given FromExpr[Color.Red.type] = FromExpr.derived +given FromExpr[Color.Green.type] = FromExpr.derived +given FromExpr[Color.Custom] = FromExpr.derived + +// Product derivation with a sum-typed field: composes `derivedProduct` (for `Container`) +// and `derivedSum` (for its `shape` field) within a single derivation. Also derives +// `ToExpr`, so the round-trip test below exercises this composition recursively (the +// outer `fromProduct`-tuple contains an inner field that is itself either another +// `fromProduct` call, for `Circle`/`Rect`, or a bare singleton reference, for `Origin`). +case class Container(name: String, shape: Shape) derives ToExpr, FromExpr + +// Product derivation: zero-arg case class. Distinct from a singleton (`Singleton` above): +// this is matched via the `Apply(fun, Nil)` branch (constructor-call recognition), not the +// bare-module-reference branch. Also derives `ToExpr`: `ToExpr.derived` produces +// `mirror.fromProduct(Tuple())` for `Blank` just as it does for a real singleton, so the +// round-trip test below confirms this correctly takes the tuple-unwrap branch rather than +// being mistaken for a singleton reference. +case class Blank() derives ToExpr, FromExpr + +// Sum derivation over a generic sealed trait (mirrors the equivalent test in the ToExpr +// suite): combines the generics-need-an-explicit-given constraint (see `Box` above) with +// sum dispatch (see `Shape` above). Also given `ToExpr`s, for the round-trip test below. +sealed trait Result[+A] +object Result: + case class Ok[A](value: A) extends Result[A] + case object Fail extends Result[Nothing] + +given resultOkFromExpr[A: Type: FromExpr]: FromExpr[Result.Ok[A]] = FromExpr.derived +given FromExpr[Result.Fail.type] = FromExpr.derived +given resultFromExpr[A: Type: FromExpr]: FromExpr[Result[A]] = FromExpr.derived +given resultOkToExpr[A: Type: ToExpr]: ToExpr[Result.Ok[A]] = ToExpr.derived +given ToExpr[Result.Fail.type] = ToExpr.derived +given resultToExpr[A: Type: ToExpr]: ToExpr[Result[A]] = ToExpr.derived + +// A case class whose arity (25) exceeds `Tuple22`: `Expr.ofTupleFromSeq` produces a +// `Tuple.fromIArray(...).asInstanceOf[...]` shape for these, which `FromExpr.derived`'s +// tuple-unwrap branch does not recognize (`TupleN.apply` matching only covers arity 0-22). +// This is a known, deliberate limitation, not a crash -- pinned down by a dedicated test +// below rather than left undocumented. +case class Big25( + f1: Int, f2: Int, f3: Int, f4: Int, f5: Int, f6: Int, f7: Int, f8: Int, f9: Int, f10: Int, + f11: Int, f12: Int, f13: Int, f14: Int, f15: Int, f16: Int, f17: Int, f18: Int, f19: Int, f20: Int, + f21: Int, f22: Int, f23: Int, f24: Int, f25: Int +) derives ToExpr, FromExpr + +object Macro: + // Matches "calls to `new X` or `X.apply`" (as `FromExpr`'s own contract puts it) -- + // both spellings of a case class construction should be recognized. + inline def matchApplyPoint: Boolean = ${ Macro.matchApplyPointImpl } + inline def matchNewPoint: Boolean = ${ Macro.matchNewPointImpl } + inline def matchNegativePoint: Boolean = ${ Macro.matchNegativePointImpl } + inline def matchMixed: Boolean = ${ Macro.matchMixedImpl } + inline def matchNestedPerson: Boolean = ${ Macro.matchNestedPersonImpl } + inline def matchDeepCompany: Boolean = ${ Macro.matchDeepCompanyImpl } + inline def matchSingleton: Boolean = ${ Macro.matchSingletonImpl } + inline def matchBoxInt: Boolean = ${ Macro.matchBoxIntImpl } + inline def matchBoxBox: Boolean = ${ Macro.matchBoxBoxImpl } + inline def matchShapeCircle: Boolean = ${ Macro.matchShapeCircleImpl } + inline def matchShapeRect: Boolean = ${ Macro.matchShapeRectImpl } + inline def matchShapeOrigin: Boolean = ${ Macro.matchShapeOriginImpl } + inline def matchColorRed: Boolean = ${ Macro.matchColorRedImpl } + inline def matchColorCustom: Boolean = ${ Macro.matchColorCustomImpl } + inline def matchContainer: Boolean = ${ Macro.matchContainerImpl } + inline def matchBlankApply: Boolean = ${ Macro.matchBlankApplyImpl } + inline def matchBlankNew: Boolean = ${ Macro.matchBlankNewImpl } + inline def matchResultOk: Boolean = ${ Macro.matchResultOkImpl } + inline def matchResultFail: Boolean = ${ Macro.matchResultFailImpl } + + // A tree wrapped in a `Typed` node (as produced by a type ascription) must be + // unwrapped before the underlying constructor call is recognized. + inline def matchAscribedPoint: Boolean = ${ Macro.matchAscribedPointImpl } + + // A tree wrapped in a `Block(Nil, ...)` node (as produced by explicit braces around a + // value, real user-reachable syntax -- not merely a defensive-only case) must likewise + // be unwrapped. + inline def matchBracedPoint: Boolean = ${ Macro.matchBracedPointImpl } + + // Not a direct constructor call: no `FromExpr` should extract a value from this. + inline def nonMatchingIsNone: Boolean = ${ Macro.nonMatchingIsNoneImpl } + // Same field count as `Point`, but a different type: arity alone must not be enough. + inline def wrongTypeIsNone: Boolean = ${ Macro.wrongTypeIsNoneImpl } + // A `Circle` tree read back as a `Rect`: same sum type, wrong variant. + inline def wrongSumVariantIsNone: Boolean = ${ Macro.wrongSumVariantIsNoneImpl } + // A 2-element tuple (from a `Point`'s `fromProduct` call) read back as a `Mixed` + // (arity 3): the tuple-unwrap branch must reject the arity mismatch, not crash. + inline def wrongArityIsNone: Boolean = ${ Macro.wrongArityIsNoneImpl } + // `Big25`'s `ToExpr.derived` output uses the `Tuple.fromIArray(...)` shape (arity > 22), + // which the tuple-unwrap branch doesn't recognize -- a documented limitation, not a + // crash. + inline def roundTripBig25IsNone: Boolean = ${ Macro.roundTripBig25IsNoneImpl } + // A `Meters`-shaped `fromProduct` tree read back as `Seconds`: same arity, same field + // type, so only the receiver-mirror check (not field-level extraction) can catch this. + inline def wrongMirrorIsNone: Boolean = ${ Macro.wrongMirrorIsNoneImpl } + + // `derived` applied directly to a tuple type: matches a literal tuple-literal quote + // (arity 2), and round-trips through `ToExpr.derived` at a higher arity (5). + inline def matchTuple2: Boolean = ${ Macro.matchTuple2Impl } + inline def roundTripTuple5: Boolean = ${ Macro.roundTripTuple5Impl } + + // Round trip: a value lifted to code via `ToExpr.derived` must be readable back via + // `FromExpr.derived` on the same type. `ToExpr.derived` always produces a + // `mirror.fromProduct(tuple)`-shaped tree (never a `T(args*)`/`new T(args*)` call), so + // this exercises the dedicated recognition branch for that shape: a product at several + // arities, a singleton (both a real case object and a `TermRef`-encoded enum case), a + // zero-arg non-singleton, a sum type, a generic type, and a product with a sum-typed + // field (composing the recognition recursively). + inline def roundTrips: Boolean = ${ Macro.roundTripsImpl } + + // Shared by (almost) every scenario above: extract `expr` via `T`'s `FromExpr` and + // compare against the value it's expected to produce (or, for `checkNone`, expect + // extraction to fail). Factored out since the comparison itself is always the same -- + // only the quoted syntax and type under test vary per scenario. + private def check[T: Type: FromExpr](expr: Expr[T], expected: T)(using Quotes): Expr[Boolean] = + Expr(summon[FromExpr[T]].unapply(expr) == Some(expected)) + + private def checkNone[T: Type: FromExpr](expr: Expr[T])(using Quotes): Expr[Boolean] = + Expr(summon[FromExpr[T]].unapply(expr).isEmpty) + + def matchApplyPointImpl(using Quotes): Expr[Boolean] = check('{ Point(1, 2) }, Point(1, 2)) + def matchNewPointImpl(using Quotes): Expr[Boolean] = check('{ new Point(1, 2) }, Point(1, 2)) + def matchNegativePointImpl(using Quotes): Expr[Boolean] = check('{ Point(-1, -2) }, Point(-1, -2)) + def matchMixedImpl(using Quotes): Expr[Boolean] = check('{ Mixed("m", true, 1.5) }, Mixed("m", true, 1.5)) + + def matchNestedPersonImpl(using Quotes): Expr[Boolean] = + check('{ Namespace.Person("nyc", Address("nyc", 10001)) }, Namespace.Person("nyc", Address("nyc", 10001))) + + def matchDeepCompanyImpl(using Quotes): Expr[Boolean] = + check( + '{ Company(Address("sf", 94107), Namespace.Person("ana", Address("nyc", 10001))) }, + Company(Address("sf", 94107), Namespace.Person("ana", Address("nyc", 10001))) + ) + + def matchSingletonImpl(using Quotes): Expr[Boolean] = check('{ Singleton }, Singleton) + def matchBoxIntImpl(using Quotes): Expr[Boolean] = check('{ Box(1) }, Box(1)) + def matchBoxBoxImpl(using Quotes): Expr[Boolean] = check('{ Box(Box("x")) }, Box(Box("x"))) + def matchShapeCircleImpl(using Quotes): Expr[Boolean] = check[Shape]('{ Shape.Circle(1.0) }, Shape.Circle(1.0)) + def matchShapeRectImpl(using Quotes): Expr[Boolean] = check[Shape]('{ Shape.Rect(1.0, 2.0) }, Shape.Rect(1.0, 2.0)) + def matchShapeOriginImpl(using Quotes): Expr[Boolean] = check[Shape]('{ Shape.Origin }, Shape.Origin) + def matchColorRedImpl(using Quotes): Expr[Boolean] = check[Color]('{ Color.Red }, Color.Red) + def matchColorCustomImpl(using Quotes): Expr[Boolean] = check[Color]('{ Color.Custom("#fff") }, Color.Custom("#fff")) + + def matchContainerImpl(using Quotes): Expr[Boolean] = + check('{ Container("c", Shape.Circle(3.0)) }, Container("c", Shape.Circle(3.0))) + + def matchBlankApplyImpl(using Quotes): Expr[Boolean] = check('{ Blank() }, Blank()) + def matchBlankNewImpl(using Quotes): Expr[Boolean] = check('{ new Blank() }, Blank()) + def matchResultOkImpl(using Quotes): Expr[Boolean] = check[Result[Int]]('{ Result.Ok(5) }, Result.Ok(5)) + def matchResultFailImpl(using Quotes): Expr[Boolean] = check[Result[Int]]('{ Result.Fail }, Result.Fail) + def matchAscribedPointImpl(using Quotes): Expr[Boolean] = check('{ (Point(1, 2): Point) }, Point(1, 2)) + def matchBracedPointImpl(using Quotes): Expr[Boolean] = check('{ { Point(1, 2) } }, Point(1, 2)) + + def nonMatchingIsNoneImpl(using Quotes): Expr[Boolean] = + checkNone('{ if true then Point(1, 2) else Point(3, 4) }) + + def wrongTypeIsNoneImpl(using Quotes): Expr[Boolean] = + val e: Expr[Point] = '{ Point(1, 2) } + checkNone(e.asInstanceOf[Expr[Address]]) + + def wrongSumVariantIsNoneImpl(using Quotes): Expr[Boolean] = + val e: Expr[Shape.Circle] = '{ Shape.Circle(1.0) } + checkNone(e.asInstanceOf[Expr[Shape.Rect]]) + + def wrongArityIsNoneImpl(using Quotes): Expr[Boolean] = + val e: Expr[Point] = Expr(Point(1, 2)) + checkNone(e.asInstanceOf[Expr[Mixed]]) + + def roundTripBig25IsNoneImpl(using Quotes): Expr[Boolean] = + val original = Big25(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25) + checkNone(Expr(original)) + + def wrongMirrorIsNoneImpl(using Quotes): Expr[Boolean] = + val e: Expr[Meters] = Expr(Meters(5)) + checkNone(e.asInstanceOf[Expr[Seconds]]) + + def matchTuple2Impl(using Quotes): Expr[Boolean] = + Expr(tuple2FromExpr.unapply('{ (1, "x") }) == Some((1, "x"))) + + def roundTripTuple5Impl(using Quotes): Expr[Boolean] = + val original = (1, "x", true, 2.5, 'c') + Expr(tuple5FromExpr.unapply(tuple5ToExpr(original)) == Some(original)) + + def roundTripsImpl(using Quotes): Expr[Boolean] = + def roundTrip[T: Type: ToExpr: FromExpr](original: T): Boolean = + summon[FromExpr[T]].unapply(Expr(original)) == Some(original) + Expr( + roundTrip(Point(1, 2)) + && roundTrip(Mixed("m", true, 1.5)) + && roundTrip(Singleton) + && roundTrip(Blank()) + && roundTrip[Shape](Shape.Circle(2.0)) + && roundTrip[Shape](Shape.Origin) + && roundTrip(Container("c", Shape.Rect(1.0, 2.0))) + && roundTrip(Box(7)) + && roundTrip[Result[Int]](Result.Ok(5)) + && roundTrip[Result[Int]](Result.Fail) + && roundTrip[Color](Color.Red) + && roundTrip[Color](Color.Custom("#fff")) + ) diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala new file mode 100644 index 000000000000..ed231fd31f3a --- /dev/null +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala @@ -0,0 +1,32 @@ +object Test: + def main(args: Array[String]): Unit = + assert(Macro.matchApplyPoint, "matchApplyPoint") + assert(Macro.matchNewPoint, "matchNewPoint") + assert(Macro.matchNegativePoint, "matchNegativePoint") + assert(Macro.matchMixed, "matchMixed") + assert(Macro.matchNestedPerson, "matchNestedPerson") + assert(Macro.matchDeepCompany, "matchDeepCompany") + assert(Macro.matchSingleton, "matchSingleton") + assert(Macro.matchBoxInt, "matchBoxInt") + assert(Macro.matchBoxBox, "matchBoxBox") + assert(Macro.matchShapeCircle, "matchShapeCircle") + assert(Macro.matchShapeRect, "matchShapeRect") + assert(Macro.matchShapeOrigin, "matchShapeOrigin") + assert(Macro.matchColorRed, "matchColorRed") + assert(Macro.matchColorCustom, "matchColorCustom") + assert(Macro.matchContainer, "matchContainer") + assert(Macro.matchBlankApply, "matchBlankApply") + assert(Macro.matchBlankNew, "matchBlankNew") + assert(Macro.matchResultOk, "matchResultOk") + assert(Macro.matchResultFail, "matchResultFail") + assert(Macro.matchAscribedPoint, "matchAscribedPoint") + assert(Macro.matchBracedPoint, "matchBracedPoint") + assert(Macro.nonMatchingIsNone, "nonMatchingIsNone") + assert(Macro.wrongTypeIsNone, "wrongTypeIsNone") + assert(Macro.wrongSumVariantIsNone, "wrongSumVariantIsNone") + assert(Macro.wrongArityIsNone, "wrongArityIsNone") + assert(Macro.roundTripBig25IsNone, "roundTripBig25IsNone") + assert(Macro.wrongMirrorIsNone, "wrongMirrorIsNone") + assert(Macro.matchTuple2, "matchTuple2") + assert(Macro.roundTripTuple5, "roundTripTuple5") + assert(Macro.roundTrips, "roundTrips") diff --git a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala new file mode 100644 index 000000000000..90ddd05e94e6 --- /dev/null +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala @@ -0,0 +1,126 @@ +import scala.quoted.* + +// Product derivation: plain case class with primitive fields. +case class Point(x: Int, y: Int) derives ToExpr + +// Product derivation: nested case classes (field itself has a derived ToExpr), and the +// case class itself is nested inside another object's companion. +case class Address(city: String, zip: Int) derives ToExpr +object Namespace: + case class Person(name: String, address: Address) derives ToExpr + +// Product derivation: case object (singleton), reconstructed via `Mirror.fromProduct` +// applied to `EmptyTuple`. +case object Singleton derives ToExpr + +// Product derivation: generic case class. `derives` only adds a `ToExpr[A]` bound to +// the generated given, not `Type[A]`, so a plain `derives ToExpr` clause on a generic +// class doesn't compile (the derived code needs to mention `A` inside a quote). Adding +// an explicit given with both bounds works. +case class Box[A](value: A) +given boxToExpr[A: Type: ToExpr]: ToExpr[Box[A]] = ToExpr.derived + +// Product derivation: case class with a variety of primitive field kinds. +case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExpr + +// Product derivation with a field type (`List[Int]`) whose `ToExpr` instance itself +// needs a `Type[Int]` (via `ListToExpr[T: Type: ToExpr]`), which can only be summoned +// where a `Quotes` is already ambient -- unlike the generic case above, adding a plain +// `Type`/`ToExpr` bound to the given doesn't help here (there's no type parameter to +// bind it to), so the given needs to be conditional on `Quotes` directly. +case class Tagged(tags: List[Int]) +given taggedToExpr(using Quotes): ToExpr[Tagged] = ToExpr.derived + +// Sum derivation: sealed hierarchy of case classes and case objects, nested inside the +// sealed trait's own companion object. The sum's derived instance only dispatches by +// ordinal, it does not recursively derive instances for its cases, so each case needs +// its own `ToExpr` instance too. +sealed trait Shape derives ToExpr +object Shape: + case class Circle(r: Double) extends Shape derives ToExpr + case class Rect(w: Double, h: Double) extends Shape derives ToExpr + case object Origin extends Shape derives ToExpr + +// Sum derivation over an enum with a mix of singleton and parameterized cases. `derives` +// on the enum doesn't propagate to individual cases, so each case still needs its own +// (explicit) `ToExpr` given. +enum Color derives ToExpr: + case Red, Green + case Custom(hex: String) + +given ToExpr[Color.Red.type] = ToExpr.derived +given ToExpr[Color.Green.type] = ToExpr.derived +given ToExpr[Color.Custom] = ToExpr.derived + +// Product derivation with a sum-typed field: composes `derivedProduct` (for `Container`) +// and `derivedSum` (for its `shape` field) within a single derivation. +case class Container(name: String, shape: Shape) derives ToExpr + +// Product derivation: zero-arg case class. Distinct from a singleton (`Singleton` above): +// this still goes through the constructor-call machinery, `fromProduct` is just applied +// to an already-empty tuple because the class happens to have no fields. +case class Blank() derives ToExpr + +// Sum derivation over a generic sealed trait: combines the generics-need-an-explicit-given +// constraint (see `Box` above) with sum dispatch (see `Shape` above). +sealed trait Result[+A] +object Result: + case class Ok[A](value: A) extends Result[A] + case object Fail extends Result[Nothing] + +given resultOkToExpr[A: Type: ToExpr]: ToExpr[Result.Ok[A]] = ToExpr.derived +given ToExpr[Result.Fail.type] = ToExpr.derived +given resultToExpr[A: Type: ToExpr]: ToExpr[Result[A]] = ToExpr.derived + +// ConstToExpr: an arbitrary (non-case) object singleton type, lifted directly via +// `valueOf[T]`, found by ordinary implicit search (no `derives` involved at all). +object Marker + +object Macro: + inline def liftPoint: Point = ${ Macro.liftPointImpl } + inline def liftPerson: Namespace.Person = ${ Macro.liftPersonImpl } + inline def liftSingleton: Singleton.type = ${ Macro.liftSingletonImpl } + inline def liftBoxInt: Box[Int] = ${ Macro.liftBoxIntImpl } + inline def liftBoxString: Box[String] = ${ Macro.liftBoxStringImpl } + inline def liftBoxBox: Box[Box[Int]] = ${ Macro.liftBoxBoxImpl } + inline def liftMixed: Mixed = ${ Macro.liftMixedImpl } + inline def liftTagged: Tagged = ${ Macro.liftTaggedImpl } + inline def liftCircle: Shape.Circle = ${ Macro.liftCircleImpl } + inline def liftShapeCircle: Shape = ${ Macro.liftShapeCircleImpl } + inline def liftShapeRect: Shape = ${ Macro.liftShapeRectImpl } + inline def liftShapeOrigin: Shape = ${ Macro.liftShapeOriginImpl } + inline def liftColorRed: Color = ${ Macro.liftColorRedImpl } + inline def liftColorGreen: Color = ${ Macro.liftColorGreenImpl } + inline def liftColorCustom: Color = ${ Macro.liftColorCustomImpl } + inline def liftMarker: Marker.type = ${ Macro.liftMarkerImpl } + inline def liftContainer: Container = ${ Macro.liftContainerImpl } + inline def liftBlank: Blank = ${ Macro.liftBlankImpl } + inline def liftResultOk: Result[Int] = ${ Macro.liftResultOkImpl } + inline def liftResultFail: Result[Int] = ${ Macro.liftResultFailImpl } + + // Regression guard: the generated code for a derived product must stay a plain + // `mirror.fromProduct(tuple)` call -- not silently regress into something that stages + // reflection (`getClass`, `Symbol.requiredClass`, ...) into the generated tree itself. + inline def showPointTree: String = ${ Macro.showPointTreeImpl } + + def liftPointImpl(using Quotes): Expr[Point] = Expr(Point(1, 2)) + def liftPersonImpl(using Quotes): Expr[Namespace.Person] = Expr(Namespace.Person("nyc", Address("nyc", 10001))) + def liftSingletonImpl(using Quotes): Expr[Singleton.type] = Expr(Singleton) + def liftBoxIntImpl(using Quotes): Expr[Box[Int]] = Expr(Box(1)) + def liftBoxStringImpl(using Quotes): Expr[Box[String]] = Expr(Box("s")) + def liftBoxBoxImpl(using Quotes): Expr[Box[Box[Int]]] = Expr(Box(Box(1))) + def liftMixedImpl(using Quotes): Expr[Mixed] = Expr(Mixed("m", true, 1.5)) + def liftTaggedImpl(using Quotes): Expr[Tagged] = Expr(Tagged(List(1, 2, 3))) + def liftCircleImpl(using Quotes): Expr[Shape.Circle] = Expr(Shape.Circle(1.0)) + def liftShapeCircleImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Circle(2.0)) + def liftShapeRectImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Rect(1.0, 2.0)) + def liftShapeOriginImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Origin) + def liftColorRedImpl(using Quotes): Expr[Color] = Expr[Color](Color.Red) + def liftColorGreenImpl(using Quotes): Expr[Color] = Expr[Color](Color.Green) + def liftColorCustomImpl(using Quotes): Expr[Color] = Expr[Color](Color.Custom("#fff")) + def liftMarkerImpl(using Quotes): Expr[Marker.type] = Expr(Marker) + def liftContainerImpl(using Quotes): Expr[Container] = Expr(Container("c", Shape.Circle(3.0))) + def liftBlankImpl(using Quotes): Expr[Blank] = Expr(Blank()) + def liftResultOkImpl(using Quotes): Expr[Result[Int]] = Expr[Result[Int]](Result.Ok(5)) + def liftResultFailImpl(using Quotes): Expr[Result[Int]] = Expr[Result[Int]](Result.Fail) + def showPointTreeImpl(using Quotes): Expr[String] = Expr(Expr(Point(1, 2)).show) diff --git a/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala b/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala new file mode 100644 index 000000000000..fc49cf73127f --- /dev/null +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala @@ -0,0 +1,23 @@ +object Test: + def main(args: Array[String]): Unit = + assert(Macro.liftPoint == Point(1, 2), Macro.liftPoint) + assert(Macro.liftPerson == Namespace.Person("nyc", Address("nyc", 10001)), Macro.liftPerson) + assert(Macro.liftSingleton == Singleton, Macro.liftSingleton) + assert(Macro.liftBoxInt == Box(1), Macro.liftBoxInt) + assert(Macro.liftBoxString == Box("s"), Macro.liftBoxString) + assert(Macro.liftBoxBox == Box(Box(1)), Macro.liftBoxBox) + assert(Macro.liftMixed == Mixed("m", true, 1.5), Macro.liftMixed) + assert(Macro.liftTagged == Tagged(List(1, 2, 3)), Macro.liftTagged) + assert(Macro.liftCircle == Shape.Circle(1.0), Macro.liftCircle) + assert(Macro.liftShapeCircle == Shape.Circle(2.0), Macro.liftShapeCircle) + assert(Macro.liftShapeRect == Shape.Rect(1.0, 2.0), Macro.liftShapeRect) + assert(Macro.liftShapeOrigin == Shape.Origin, Macro.liftShapeOrigin) + assert(Macro.liftColorRed == Color.Red, Macro.liftColorRed) + assert(Macro.liftColorGreen == Color.Green, Macro.liftColorGreen) + assert(Macro.liftColorCustom == Color.Custom("#fff"), Macro.liftColorCustom) + assert(Macro.liftMarker == Marker, Macro.liftMarker) + assert(Macro.liftContainer == Container("c", Shape.Circle(3.0)), Macro.liftContainer) + assert(Macro.liftBlank == Blank(), Macro.liftBlank) + assert(Macro.liftResultOk == Result.Ok(5), Macro.liftResultOk) + assert(Macro.liftResultFail == Result.Fail, Macro.liftResultFail) + assert(Macro.showPointTree.contains("fromProduct"), Macro.showPointTree) From 5616c9746e689a7cd1fbf7a1dd5f846e9706566b Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 10:27:08 +0200 Subject: [PATCH 02/17] Add nested sum derivation for Vehicle and Arith with corresponding tests --- .../Macro_1.scala | 58 +++++++++++++++++++ .../Test_2.scala | 5 ++ 2 files changed, 63 insertions(+) diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala index 83067e5a4f02..0237a1d4d749 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -101,6 +101,34 @@ given resultOkToExpr[A: Type: ToExpr]: ToExpr[Result.Ok[A]] = ToExpr.derived given ToExpr[Result.Fail.type] = ToExpr.derived given resultToExpr[A: Type: ToExpr]: ToExpr[Result[A]] = ToExpr.derived +// Sum derivation nested two levels deep: a sealed trait whose own case is ITSELF a sealed +// trait with further cases, to confirm dispatch recurses through nested sums (each level +// just needs the next level's own derived instance) rather than only a single level of +// `Mirror.SumOf`. Also derives `ToExpr`, for the round-trip test below. +sealed trait Vehicle derives ToExpr, FromExpr +object Vehicle: + sealed trait Motorized extends Vehicle derives ToExpr, FromExpr + object Motorized: + case class Car(wheels: Int) extends Motorized derives ToExpr, FromExpr + case class Motorcycle(cc: Int) extends Motorized derives ToExpr, FromExpr + case class Bicycle(gears: Int) extends Vehicle derives ToExpr, FromExpr + +// Recursive sum: a case's own field refers back to the enum being derived, so deriving +// must tolerate this self/mutually-recursive summon (the generated given for `Arith` +// itself, and the per-case givens below that need `FromExpr[Arith]` for their `Arith`-typed +// fields, resolve each other regardless of declaration order). Also derives `ToExpr`, for +// the round-trip test below. +enum Arith derives ToExpr, FromExpr: + case Lit(n: Int) + case Add(l: Arith, r: Arith) + case Neg(e: Arith) + +given ToExpr[Arith.Lit] = ToExpr.derived +given ToExpr[Arith.Add] = ToExpr.derived +given ToExpr[Arith.Neg] = ToExpr.derived +given FromExpr[Arith.Lit] = FromExpr.derived +given FromExpr[Arith.Add] = FromExpr.derived +given FromExpr[Arith.Neg] = FromExpr.derived // A case class whose arity (25) exceeds `Tuple22`: `Expr.ofTupleFromSeq` produces a // `Tuple.fromIArray(...).asInstanceOf[...]` shape for these, which `FromExpr.derived`'s // tuple-unwrap branch does not recognize (`TupleN.apply` matching only covers arity 0-22). @@ -135,6 +163,15 @@ object Macro: inline def matchResultOk: Boolean = ${ Macro.matchResultOkImpl } inline def matchResultFail: Boolean = ${ Macro.matchResultFailImpl } + inline def matchVehicleCar: Boolean = ${ Macro.matchVehicleCarImpl } + inline def matchVehicleMotorcycle: Boolean = ${ Macro.matchVehicleMotorcycleImpl } + inline def matchVehicleBicycle: Boolean = ${ Macro.matchVehicleBicycleImpl } + // A `Car` tree read back as a `Motorcycle`: both are cases of the same nested `Motorized` + // sum, so this exercises the wrong-variant check one level deeper than `wrongSumVariantIsNone`. + inline def wrongNestedVariantIsNone: Boolean = ${ Macro.wrongNestedVariantIsNoneImpl } + + inline def matchArithNested: Boolean = ${ Macro.matchArithNestedImpl } + // A tree wrapped in a `Typed` node (as produced by a type ascription) must be // unwrapped before the underlying constructor call is recognized. inline def matchAscribedPoint: Boolean = ${ Macro.matchAscribedPointImpl } @@ -215,6 +252,24 @@ object Macro: def matchBlankNewImpl(using Quotes): Expr[Boolean] = check('{ new Blank() }, Blank()) def matchResultOkImpl(using Quotes): Expr[Boolean] = check[Result[Int]]('{ Result.Ok(5) }, Result.Ok(5)) def matchResultFailImpl(using Quotes): Expr[Boolean] = check[Result[Int]]('{ Result.Fail }, Result.Fail) + + def matchVehicleCarImpl(using Quotes): Expr[Boolean] = + check[Vehicle]('{ Vehicle.Motorized.Car(4) }, Vehicle.Motorized.Car(4)) + def matchVehicleMotorcycleImpl(using Quotes): Expr[Boolean] = + check[Vehicle]('{ Vehicle.Motorized.Motorcycle(650) }, Vehicle.Motorized.Motorcycle(650)) + def matchVehicleBicycleImpl(using Quotes): Expr[Boolean] = + check[Vehicle]('{ Vehicle.Bicycle(21) }, Vehicle.Bicycle(21)) + + def wrongNestedVariantIsNoneImpl(using Quotes): Expr[Boolean] = + val e: Expr[Vehicle.Motorized.Car] = '{ Vehicle.Motorized.Car(4) } + checkNone(e.asInstanceOf[Expr[Vehicle.Motorized.Motorcycle]]) + + def matchArithNestedImpl(using Quotes): Expr[Boolean] = + check[Arith]( + '{ Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3)))) }, + Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3)))) + ) + def matchAscribedPointImpl(using Quotes): Expr[Boolean] = check('{ (Point(1, 2): Point) }, Point(1, 2)) def matchBracedPointImpl(using Quotes): Expr[Boolean] = check('{ { Point(1, 2) } }, Point(1, 2)) @@ -264,4 +319,7 @@ object Macro: && roundTrip[Result[Int]](Result.Fail) && roundTrip[Color](Color.Red) && roundTrip[Color](Color.Custom("#fff")) + && roundTrip[Vehicle](Vehicle.Motorized.Car(4)) + && roundTrip[Vehicle](Vehicle.Bicycle(21)) + && roundTrip(Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3))))) ) diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala index ed231fd31f3a..0c684f8122e6 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala @@ -19,6 +19,11 @@ object Test: assert(Macro.matchBlankNew, "matchBlankNew") assert(Macro.matchResultOk, "matchResultOk") assert(Macro.matchResultFail, "matchResultFail") + assert(Macro.matchVehicleCar, "matchVehicleCar") + assert(Macro.matchVehicleMotorcycle, "matchVehicleMotorcycle") + assert(Macro.matchVehicleBicycle, "matchVehicleBicycle") + assert(Macro.wrongNestedVariantIsNone, "wrongNestedVariantIsNone") + assert(Macro.matchArithNested, "matchArithNested") assert(Macro.matchAscribedPoint, "matchAscribedPoint") assert(Macro.matchBracedPoint, "matchBracedPoint") assert(Macro.nonMatchingIsNone, "nonMatchingIsNone") From 398a5334e5a437fa85e5a3b7f91eccedf3e58e7b Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 11:42:11 +0200 Subject: [PATCH 03/17] Auto-derive a sum's own case instances A sealed hierarchy now only needs `derives ToExpr, FromExpr` on its outermost type; each case's own instance is derived automatically if none is already in scope, recursing through as many levels of nested sums as needed. Product fields are unaffected -- they're a type's own external dependencies, not its cases, so they still need their own instance. Also adds nested-sum-hierarchy test coverage (Vehicle -> Motorized -> Car/Motorcycle), including a wrong-variant check one level into the nested sum. Note: this does not (and cannot) extend to a genuinely recursive sum, e.g. `enum Arith { case Add(l: Arith, r: Arith) }`. Deriving both the sum's own instance and a case's instance as separate top-level givens creates a circular value dependency that Scala's thread-safe lazy val initialization deadlocks on (confirmed via a thread dump), regardless of whether the case's instance is hand-written or auto-derived. Such recursive types are out of scope for this derivation mechanism. Co-Authored-By: Claude Sonnet 5 --- library/src/scala/quoted/FromExpr.scala | 23 +++-- library/src/scala/quoted/ToExpr.scala | 21 +++-- .../Macro_1.scala | 94 ++++++++----------- .../Test_2.scala | 1 - .../Macro_1.scala | 35 +++---- 5 files changed, 85 insertions(+), 89 deletions(-) diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index aae7a88c7691..afc5e522d64a 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -34,17 +34,22 @@ object FromExpr { import scala.deriving.Mirror - /** Derives a `FromExpr[T]` using its `Mirror`; also recognizes `ToExpr.derived`'s own - * `mirror.fromProduct(tuple)` output, so deriving both on the same type round-trips. - */ - inline def derived[T: Mirror.Of as m]: FromExpr[T] = - val elemInstances = compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExpr]].toList.asInstanceOf[List[FromExpr[Any]]] - inline m match - case given Mirror.ProductOf[T] => derivedProduct[T](elemInstances) - case given Mirror.SumOf[T] => derivedSum[T](elemInstances) + inline def derived[T: Mirror.Of as m]: FromExpr[T] = inline m match + case given Mirror.ProductOf[T] => + derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExpr]].toList.asInstanceOf[List[FromExpr[Any]]]) + case given Mirror.SumOf[T] => + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) + + private inline def summonAllOrDerive[Elems <: Tuple]: List[FromExpr[Any]] = inline compiletime.erasedValue[Elems] match + case _: EmptyTuple => Nil + case _: (h *: t) => summonOrDerive[h].asInstanceOf[FromExpr[Any]] :: summonAllOrDerive[t] + + private inline def summonOrDerive[C]: FromExpr[C] = compiletime.summonFrom: + case fe: FromExpr[C] => fe + case given Mirror.Of[C] => derived[C] @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] - private inline def derivedProduct[T](elemInstances: List[FromExpr[Any]])(using m: Mirror.ProductOf[T]): FromExpr[T] = new FromExpr[T]: + private inline def derivedProduct[T: Mirror.ProductOf as m](elemInstances: List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = import quotes.reflect.* val tpe = TypeRepr.of[T] diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 551fdce27bcd..c7ee1a5f9747 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -26,13 +26,20 @@ object ToExpr { import scala.deriving.Mirror import scala.quoted.* - inline def derived[T: Mirror.Of as m]: ToExpr[T] = - type Elems = m.MirroredElemTypes - val elemInstances = compiletime.summonAll[Tuple.Map[Elems, ToExpr]].toList.asInstanceOf[List[ToExpr[Any]]] - m match - case given Mirror.ProductOf[T] => derivedProduct[T](elemInstances) - case given Mirror.SumOf[T] => derivedSum[T](elemInstances) - + inline def derived[T: Mirror.Of as m]: ToExpr[T] = inline m match + case given Mirror.ProductOf[T] => + derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExpr]].toList.asInstanceOf[List[ToExpr[Any]]]) + case given Mirror.SumOf[T] => + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) + + private inline def summonAllOrDerive[Elems <: Tuple]: List[ToExpr[Any]] = inline compiletime.erasedValue[Elems] match + case _: EmptyTuple => Nil + case _: (h *: t) => summonOrDerive[h].asInstanceOf[ToExpr[Any]] :: summonAllOrDerive[t] + + private inline def summonOrDerive[C]: ToExpr[C] = compiletime.summonFrom: + case te: ToExpr[C] => te + case given Mirror.Of[C] => derived[C] + @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] private inline def derivedProduct[T: Mirror.ProductOf](elemInstances: List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: def apply(x: T)(using Quotes): Expr[T] = diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala index 0237a1d4d749..418da39d53bf 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -46,31 +46,25 @@ given boxFromExpr[A: Type: FromExpr]: FromExpr[Box[A]] = FromExpr.derived given boxToExpr[A: Type: ToExpr]: ToExpr[Box[A]] = ToExpr.derived // Sum derivation: sealed hierarchy of case classes and case objects, nested inside the -// sealed trait's own companion object. Each case needs its own instance; the sum type's -// own instance just tries each case's `unapply` in turn. -// Also derives `ToExpr` on the sum type and its variants, for the round-trip test below. +// sealed trait's own companion object. Only the sealed trait itself needs `derives` -- its +// own cases are derived automatically since none of them already has an instance in scope; +// the sum type's own instance just tries each case's `unapply` in turn. +// Also derives `ToExpr` on the sum type, for the round-trip test below. sealed trait Shape derives ToExpr, FromExpr object Shape: - case class Circle(r: Double) extends Shape derives ToExpr, FromExpr - case class Rect(w: Double, h: Double) extends Shape derives ToExpr, FromExpr - case object Origin extends Shape derives ToExpr, FromExpr + case class Circle(r: Double) extends Shape + case class Rect(w: Double, h: Double) extends Shape + case object Origin extends Shape // Sum derivation over an enum with a mix of singleton and parameterized cases (mirrors -// the equivalent test in the ToExpr suite). Each case still needs its own instance. Also -// derives `ToExpr` (on the enum and each case), for the round-trip test below -- an enum -// singleton's `Type[T]` is `TermRef`-encoded (see the fix in `FromExpr.derivedProduct`), -// distinct from a real case object's `TypeRef`-encoded module class. +// the equivalent test in the ToExpr suite). Only the enum itself needs `derives` -- an +// enum singleton's `Type[T]` is `TermRef`-encoded (see the fix in `FromExpr.derivedProduct`), +// distinct from a real case object's `TypeRef`-encoded module class, but that doesn't +// change anything about deriving its cases automatically. enum Color derives ToExpr, FromExpr: case Red, Green case Custom(hex: String) -given ToExpr[Color.Red.type] = ToExpr.derived -given ToExpr[Color.Green.type] = ToExpr.derived -given ToExpr[Color.Custom] = ToExpr.derived -given FromExpr[Color.Red.type] = FromExpr.derived -given FromExpr[Color.Green.type] = FromExpr.derived -given FromExpr[Color.Custom] = FromExpr.derived - // Product derivation with a sum-typed field: composes `derivedProduct` (for `Container`) // and `derivedSum` (for its `shape` field) within a single derivation. Also derives // `ToExpr`, so the round-trip test below exercises this composition recursively (the @@ -88,47 +82,40 @@ case class Blank() derives ToExpr, FromExpr // Sum derivation over a generic sealed trait (mirrors the equivalent test in the ToExpr // suite): combines the generics-need-an-explicit-given constraint (see `Box` above) with -// sum dispatch (see `Shape` above). Also given `ToExpr`s, for the round-trip test below. +// sum dispatch (see `Shape` above). The sealed trait itself still needs the explicit +// `Type[A]`/instance-bound given (`derives` alone can't add it, same reason as `Box`), but +// its cases (`Ok`, `Fail`) no longer need one of their own -- they're derived automatically +// as part of deriving `Result[A]`, with `A`'s own `Type`/`FromExpr` bound already in scope +// from the outer given. sealed trait Result[+A] object Result: case class Ok[A](value: A) extends Result[A] case object Fail extends Result[Nothing] -given resultOkFromExpr[A: Type: FromExpr]: FromExpr[Result.Ok[A]] = FromExpr.derived -given FromExpr[Result.Fail.type] = FromExpr.derived given resultFromExpr[A: Type: FromExpr]: FromExpr[Result[A]] = FromExpr.derived -given resultOkToExpr[A: Type: ToExpr]: ToExpr[Result.Ok[A]] = ToExpr.derived -given ToExpr[Result.Fail.type] = ToExpr.derived given resultToExpr[A: Type: ToExpr]: ToExpr[Result[A]] = ToExpr.derived // Sum derivation nested two levels deep: a sealed trait whose own case is ITSELF a sealed -// trait with further cases, to confirm dispatch recurses through nested sums (each level -// just needs the next level's own derived instance) rather than only a single level of -// `Mirror.SumOf`. Also derives `ToExpr`, for the round-trip test below. +// trait with further cases, to confirm dispatch recurses through nested sums -- each level +// only needs its own `derives`, the auto-derivation cascades down through as many levels +// of `Mirror.SumOf` as needed. Also derives `ToExpr`, for the round-trip test below. sealed trait Vehicle derives ToExpr, FromExpr object Vehicle: - sealed trait Motorized extends Vehicle derives ToExpr, FromExpr + sealed trait Motorized extends Vehicle object Motorized: - case class Car(wheels: Int) extends Motorized derives ToExpr, FromExpr - case class Motorcycle(cc: Int) extends Motorized derives ToExpr, FromExpr - case class Bicycle(gears: Int) extends Vehicle derives ToExpr, FromExpr - -// Recursive sum: a case's own field refers back to the enum being derived, so deriving -// must tolerate this self/mutually-recursive summon (the generated given for `Arith` -// itself, and the per-case givens below that need `FromExpr[Arith]` for their `Arith`-typed -// fields, resolve each other regardless of declaration order). Also derives `ToExpr`, for -// the round-trip test below. -enum Arith derives ToExpr, FromExpr: - case Lit(n: Int) - case Add(l: Arith, r: Arith) - case Neg(e: Arith) - -given ToExpr[Arith.Lit] = ToExpr.derived -given ToExpr[Arith.Add] = ToExpr.derived -given ToExpr[Arith.Neg] = ToExpr.derived -given FromExpr[Arith.Lit] = FromExpr.derived -given FromExpr[Arith.Add] = FromExpr.derived -given FromExpr[Arith.Neg] = FromExpr.derived + case class Car(wheels: Int) extends Motorized + case class Motorcycle(cc: Int) extends Motorized + case class Bicycle(gears: Int) extends Vehicle + +// NOTE: a genuinely recursive sum (a case whose own field type is the enclosing sum, e.g. +// `enum Arith { case Add(l: Arith, r: Arith) }`) is deliberately NOT covered here. Deriving +// both the sum's own instance and each case's instance as separate top-level givens creates +// a circular value dependency between them (the sum's instance needs the case's instance, +// which needs the sum's instance back) -- and Scala 3's thread-safe lazy val implementation +// does not tolerate this: it deadlocks waiting on its own `CountDownLatch`, confirmed via a +// thread dump (not a hypothetical). This is a Scala-level limitation of recursive Mirror +// derivation via separate top-level givens, not something fixable from this library's code. + // A case class whose arity (25) exceeds `Tuple22`: `Expr.ofTupleFromSeq` produces a // `Tuple.fromIArray(...).asInstanceOf[...]` shape for these, which `FromExpr.derived`'s // tuple-unwrap branch does not recognize (`TupleN.apply` matching only covers arity 0-22). @@ -170,8 +157,6 @@ object Macro: // sum, so this exercises the wrong-variant check one level deeper than `wrongSumVariantIsNone`. inline def wrongNestedVariantIsNone: Boolean = ${ Macro.wrongNestedVariantIsNoneImpl } - inline def matchArithNested: Boolean = ${ Macro.matchArithNestedImpl } - // A tree wrapped in a `Typed` node (as produced by a type ascription) must be // unwrapped before the underlying constructor call is recognized. inline def matchAscribedPoint: Boolean = ${ Macro.matchAscribedPointImpl } @@ -261,15 +246,13 @@ object Macro: check[Vehicle]('{ Vehicle.Bicycle(21) }, Vehicle.Bicycle(21)) def wrongNestedVariantIsNoneImpl(using Quotes): Expr[Boolean] = + // `Car`/`Motorcycle` no longer have their own top-level `FromExpr` (they're derived + // automatically as part of `Vehicle`'s own dispatch, not exposed standalone), so derive + // one locally just to check this specific leaf-to-leaf mismatch. + given FromExpr[Vehicle.Motorized.Motorcycle] = FromExpr.derived val e: Expr[Vehicle.Motorized.Car] = '{ Vehicle.Motorized.Car(4) } checkNone(e.asInstanceOf[Expr[Vehicle.Motorized.Motorcycle]]) - def matchArithNestedImpl(using Quotes): Expr[Boolean] = - check[Arith]( - '{ Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3)))) }, - Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3)))) - ) - def matchAscribedPointImpl(using Quotes): Expr[Boolean] = check('{ (Point(1, 2): Point) }, Point(1, 2)) def matchBracedPointImpl(using Quotes): Expr[Boolean] = check('{ { Point(1, 2) } }, Point(1, 2)) @@ -281,6 +264,8 @@ object Macro: checkNone(e.asInstanceOf[Expr[Address]]) def wrongSumVariantIsNoneImpl(using Quotes): Expr[Boolean] = + // `Rect` no longer has its own top-level `FromExpr` (see `wrongNestedVariantIsNoneImpl`). + given FromExpr[Shape.Rect] = FromExpr.derived val e: Expr[Shape.Circle] = '{ Shape.Circle(1.0) } checkNone(e.asInstanceOf[Expr[Shape.Rect]]) @@ -321,5 +306,4 @@ object Macro: && roundTrip[Color](Color.Custom("#fff")) && roundTrip[Vehicle](Vehicle.Motorized.Car(4)) && roundTrip[Vehicle](Vehicle.Bicycle(21)) - && roundTrip(Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3))))) ) diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala index 0c684f8122e6..88e0b85d2f1f 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala @@ -23,7 +23,6 @@ object Test: assert(Macro.matchVehicleMotorcycle, "matchVehicleMotorcycle") assert(Macro.matchVehicleBicycle, "matchVehicleBicycle") assert(Macro.wrongNestedVariantIsNone, "wrongNestedVariantIsNone") - assert(Macro.matchArithNested, "matchArithNested") assert(Macro.matchAscribedPoint, "matchAscribedPoint") assert(Macro.matchBracedPoint, "matchBracedPoint") assert(Macro.nonMatchingIsNone, "nonMatchingIsNone") diff --git a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala index 90ddd05e94e6..47e188cd0905 100644 --- a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala @@ -32,26 +32,21 @@ case class Tagged(tags: List[Int]) given taggedToExpr(using Quotes): ToExpr[Tagged] = ToExpr.derived // Sum derivation: sealed hierarchy of case classes and case objects, nested inside the -// sealed trait's own companion object. The sum's derived instance only dispatches by -// ordinal, it does not recursively derive instances for its cases, so each case needs -// its own `ToExpr` instance too. +// sealed trait's own companion object. Only the sealed trait itself needs `derives` -- its +// own cases are derived automatically since none of them already has an instance in scope; +// the sum's derived instance just dispatches by ordinal to whichever case it picks up. sealed trait Shape derives ToExpr object Shape: - case class Circle(r: Double) extends Shape derives ToExpr - case class Rect(w: Double, h: Double) extends Shape derives ToExpr - case object Origin extends Shape derives ToExpr + case class Circle(r: Double) extends Shape + case class Rect(w: Double, h: Double) extends Shape + case object Origin extends Shape -// Sum derivation over an enum with a mix of singleton and parameterized cases. `derives` -// on the enum doesn't propagate to individual cases, so each case still needs its own -// (explicit) `ToExpr` given. +// Sum derivation over an enum with a mix of singleton and parameterized cases. Only the +// enum itself needs `derives` -- its cases are derived automatically, the same as `Shape`. enum Color derives ToExpr: case Red, Green case Custom(hex: String) -given ToExpr[Color.Red.type] = ToExpr.derived -given ToExpr[Color.Green.type] = ToExpr.derived -given ToExpr[Color.Custom] = ToExpr.derived - // Product derivation with a sum-typed field: composes `derivedProduct` (for `Container`) // and `derivedSum` (for its `shape` field) within a single derivation. case class Container(name: String, shape: Shape) derives ToExpr @@ -62,14 +57,15 @@ case class Container(name: String, shape: Shape) derives ToExpr case class Blank() derives ToExpr // Sum derivation over a generic sealed trait: combines the generics-need-an-explicit-given -// constraint (see `Box` above) with sum dispatch (see `Shape` above). +// constraint (see `Box` above) with sum dispatch (see `Shape` above). The sealed trait +// itself still needs the explicit `Type[A]`/instance-bound given, but its cases (`Ok`, +// `Fail`) no longer need one of their own -- `A`'s own bound is already in scope from the +// outer given. sealed trait Result[+A] object Result: case class Ok[A](value: A) extends Result[A] case object Fail extends Result[Nothing] -given resultOkToExpr[A: Type: ToExpr]: ToExpr[Result.Ok[A]] = ToExpr.derived -given ToExpr[Result.Fail.type] = ToExpr.derived given resultToExpr[A: Type: ToExpr]: ToExpr[Result[A]] = ToExpr.derived // ConstToExpr: an arbitrary (non-case) object singleton type, lifted directly via @@ -111,7 +107,12 @@ object Macro: def liftBoxBoxImpl(using Quotes): Expr[Box[Box[Int]]] = Expr(Box(Box(1))) def liftMixedImpl(using Quotes): Expr[Mixed] = Expr(Mixed("m", true, 1.5)) def liftTaggedImpl(using Quotes): Expr[Tagged] = Expr(Tagged(List(1, 2, 3))) - def liftCircleImpl(using Quotes): Expr[Shape.Circle] = Expr(Shape.Circle(1.0)) + def liftCircleImpl(using Quotes): Expr[Shape.Circle] = + // `Circle` no longer has its own top-level `ToExpr` (it's derived automatically as part + // of `Shape`'s own dispatch, not exposed standalone), so derive one locally to lift it + // directly (as opposed to `liftShapeCircleImpl` below, which goes through `Shape`). + given ToExpr[Shape.Circle] = ToExpr.derived + Expr(Shape.Circle(1.0)) def liftShapeCircleImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Circle(2.0)) def liftShapeRectImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Rect(1.0, 2.0)) def liftShapeOriginImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Origin) From bb1f44fdc6b07e6fa5d4c23f163112c7d207abf1 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 12:08:39 +0200 Subject: [PATCH 04/17] cleanup comments --- .../Macro_1.scala | 144 +++++------------- .../Macro_1.scala | 58 ++----- 2 files changed, 51 insertions(+), 151 deletions(-) diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala index 418da39d53bf..b678a62ef9e0 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -1,104 +1,64 @@ import scala.quoted.* -// Product derivation: plain case class with primitive fields. Also derives `ToExpr`, so -// this doubles as the round-trip test type below. +// Plain product, primitives case class Point(x: Int, y: Int) derives ToExpr, FromExpr -// Product derivation: case class with a variety of primitive field kinds. Also derives -// `ToExpr`, to exercise the round-trip test at an arity (3) beyond the smallest cases. +// Product, mixed field kinds case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExpr, FromExpr -// Same shape (one Int field) as each other, but nominally distinct types: proves the -// `fromProduct` recognition branch checks the receiver is specifically `Mirror.ProductOf[T]` -// rather than accepting any same-arity `fromProduct` call (which would let a `Meters` tree -// be silently misread as a `Seconds` value, since field-level extraction alone can't catch -// the mismatch when the field types happen to coincide too). +// Same shape, different types (wrong-mirror guard) case class Meters(value: Int) derives ToExpr, FromExpr case class Seconds(value: Int) derives ToExpr, FromExpr -// `Mirror.ProductOf` exists for tuple types too, so `derived` works when `T` itself is a -// tuple -- not just when a tuple shows up as the argument to some other type's -// `fromProduct` call. Named explicitly (rather than via `derives`, which isn't valid syntax -// on a type alias) to avoid shadowing/ambiguity with the library's own hand-written -// `Tuple2FromExpr`/`Tuple5FromExpr` givens when summoned generically elsewhere. +// `derived` on a tuple type directly given tuple2FromExpr: FromExpr[(Int, String)] = FromExpr.derived given tuple2ToExpr: ToExpr[(Int, String)] = ToExpr.derived given tuple5FromExpr: FromExpr[(Int, String, Boolean, Double, Char)] = FromExpr.derived given tuple5ToExpr: ToExpr[(Int, String, Boolean, Double, Char)] = ToExpr.derived -// Product derivation: nested case classes, one nested inside another object's companion. +// Nested products, cross-object case class Address(city: String, zip: Int) derives FromExpr object Namespace: case class Person(name: String, address: Address) derives FromExpr -// Three levels of nesting, to make sure recursion isn't hardcoded to depth 1-2. +// Three levels of nesting case class Company(hq: Address, ceo: Namespace.Person) derives FromExpr -// Product derivation: case object (singleton). Matches a bare reference to the module, -// not a call. Also derives `ToExpr`, for the round-trip test below. +// Singleton (case object) case object Singleton derives ToExpr, FromExpr -// Product derivation: generic case class. Just like `ToExpr`, `derives` only adds a -// `FromExpr[A]` bound (not `Type[A]`), so a generic class needs an explicit given. Also -// given a `ToExpr`, for the round-trip test below. +// Generic product (needs an explicit Type/instance bound) case class Box[A](value: A) -given boxFromExpr[A: Type: FromExpr]: FromExpr[Box[A]] = FromExpr.derived -given boxToExpr[A: Type: ToExpr]: ToExpr[Box[A]] = ToExpr.derived - -// Sum derivation: sealed hierarchy of case classes and case objects, nested inside the -// sealed trait's own companion object. Only the sealed trait itself needs `derives` -- its -// own cases are derived automatically since none of them already has an instance in scope; -// the sum type's own instance just tries each case's `unapply` in turn. -// Also derives `ToExpr` on the sum type, for the round-trip test below. +given [A: {Type, ToExpr}] => ToExpr[Box[A]] = ToExpr.derived +given [A: {Type, FromExpr}] => FromExpr[Box[A]] = FromExpr.derived + +// Sum: sealed trait + cases, auto-derived sealed trait Shape derives ToExpr, FromExpr object Shape: case class Circle(r: Double) extends Shape case class Rect(w: Double, h: Double) extends Shape case object Origin extends Shape -// Sum derivation over an enum with a mix of singleton and parameterized cases (mirrors -// the equivalent test in the ToExpr suite). Only the enum itself needs `derives` -- an -// enum singleton's `Type[T]` is `TermRef`-encoded (see the fix in `FromExpr.derivedProduct`), -// distinct from a real case object's `TypeRef`-encoded module class, but that doesn't -// change anything about deriving its cases automatically. +// Sum: enum, singleton + parameterized cases enum Color derives ToExpr, FromExpr: case Red, Green case Custom(hex: String) -// Product derivation with a sum-typed field: composes `derivedProduct` (for `Container`) -// and `derivedSum` (for its `shape` field) within a single derivation. Also derives -// `ToExpr`, so the round-trip test below exercises this composition recursively (the -// outer `fromProduct`-tuple contains an inner field that is itself either another -// `fromProduct` call, for `Circle`/`Rect`, or a bare singleton reference, for `Origin`). +// Product with a sum-typed field case class Container(name: String, shape: Shape) derives ToExpr, FromExpr -// Product derivation: zero-arg case class. Distinct from a singleton (`Singleton` above): -// this is matched via the `Apply(fun, Nil)` branch (constructor-call recognition), not the -// bare-module-reference branch. Also derives `ToExpr`: `ToExpr.derived` produces -// `mirror.fromProduct(Tuple())` for `Blank` just as it does for a real singleton, so the -// round-trip test below confirms this correctly takes the tuple-unwrap branch rather than -// being mistaken for a singleton reference. +// Zero-arg product (not a singleton) case class Blank() derives ToExpr, FromExpr -// Sum derivation over a generic sealed trait (mirrors the equivalent test in the ToExpr -// suite): combines the generics-need-an-explicit-given constraint (see `Box` above) with -// sum dispatch (see `Shape` above). The sealed trait itself still needs the explicit -// `Type[A]`/instance-bound given (`derives` alone can't add it, same reason as `Box`), but -// its cases (`Ok`, `Fail`) no longer need one of their own -- they're derived automatically -// as part of deriving `Result[A]`, with `A`'s own `Type`/`FromExpr` bound already in scope -// from the outer given. +// Generic sum (explicit bound on the trait; cases auto-derived) sealed trait Result[+A] object Result: case class Ok[A](value: A) extends Result[A] case object Fail extends Result[Nothing] +given [A: {Type, FromExpr}] => FromExpr[Result[A]] = FromExpr.derived +given [A: {Type, ToExpr}] => ToExpr[Result[A]] = ToExpr.derived -given resultFromExpr[A: Type: FromExpr]: FromExpr[Result[A]] = FromExpr.derived -given resultToExpr[A: Type: ToExpr]: ToExpr[Result[A]] = ToExpr.derived - -// Sum derivation nested two levels deep: a sealed trait whose own case is ITSELF a sealed -// trait with further cases, to confirm dispatch recurses through nested sums -- each level -// only needs its own `derives`, the auto-derivation cascades down through as many levels -// of `Mirror.SumOf` as needed. Also derives `ToExpr`, for the round-trip test below. +// Nested sum hierarchy, two levels of dispatch sealed trait Vehicle derives ToExpr, FromExpr object Vehicle: sealed trait Motorized extends Vehicle @@ -107,20 +67,10 @@ object Vehicle: case class Motorcycle(cc: Int) extends Motorized case class Bicycle(gears: Int) extends Vehicle -// NOTE: a genuinely recursive sum (a case whose own field type is the enclosing sum, e.g. -// `enum Arith { case Add(l: Arith, r: Arith) }`) is deliberately NOT covered here. Deriving -// both the sum's own instance and each case's instance as separate top-level givens creates -// a circular value dependency between them (the sum's instance needs the case's instance, -// which needs the sum's instance back) -- and Scala 3's thread-safe lazy val implementation -// does not tolerate this: it deadlocks waiting on its own `CountDownLatch`, confirmed via a -// thread dump (not a hypothetical). This is a Scala-level limitation of recursive Mirror -// derivation via separate top-level givens, not something fixable from this library's code. - -// A case class whose arity (25) exceeds `Tuple22`: `Expr.ofTupleFromSeq` produces a -// `Tuple.fromIArray(...).asInstanceOf[...]` shape for these, which `FromExpr.derived`'s -// tuple-unwrap branch does not recognize (`TupleN.apply` matching only covers arity 0-22). -// This is a known, deliberate limitation, not a crash -- pinned down by a dedicated test -// below rather than left undocumented. +// NOTE: a genuinely recursive sum (e.g. `Add(l: Arith, r: Arith)`) deadlocks during +// derivation (circular top-level given initialization) -- out of scope, see SLC. + +// Arity > 22 (known limitation, not a crash) case class Big25( f1: Int, f2: Int, f3: Int, f4: Int, f5: Int, f6: Int, f7: Int, f8: Int, f9: Int, f10: Int, f11: Int, f12: Int, f13: Int, f14: Int, f15: Int, f16: Int, f17: Int, f18: Int, f19: Int, f20: Int, @@ -128,8 +78,7 @@ case class Big25( ) derives ToExpr, FromExpr object Macro: - // Matches "calls to `new X` or `X.apply`" (as `FromExpr`'s own contract puts it) -- - // both spellings of a case class construction should be recognized. + // Constructor-call recognition: `apply` and `new` inline def matchApplyPoint: Boolean = ${ Macro.matchApplyPointImpl } inline def matchNewPoint: Boolean = ${ Macro.matchNewPointImpl } inline def matchNegativePoint: Boolean = ${ Macro.matchNegativePointImpl } @@ -153,54 +102,35 @@ object Macro: inline def matchVehicleCar: Boolean = ${ Macro.matchVehicleCarImpl } inline def matchVehicleMotorcycle: Boolean = ${ Macro.matchVehicleMotorcycleImpl } inline def matchVehicleBicycle: Boolean = ${ Macro.matchVehicleBicycleImpl } - // A `Car` tree read back as a `Motorcycle`: both are cases of the same nested `Motorized` - // sum, so this exercises the wrong-variant check one level deeper than `wrongSumVariantIsNone`. + // Nested-sum wrong-variant guard inline def wrongNestedVariantIsNone: Boolean = ${ Macro.wrongNestedVariantIsNoneImpl } - // A tree wrapped in a `Typed` node (as produced by a type ascription) must be - // unwrapped before the underlying constructor call is recognized. + // `Typed` node unwrapping inline def matchAscribedPoint: Boolean = ${ Macro.matchAscribedPointImpl } - // A tree wrapped in a `Block(Nil, ...)` node (as produced by explicit braces around a - // value, real user-reachable syntax -- not merely a defensive-only case) must likewise - // be unwrapped. + // `Block(Nil, ...)` node unwrapping inline def matchBracedPoint: Boolean = ${ Macro.matchBracedPointImpl } - // Not a direct constructor call: no `FromExpr` should extract a value from this. + // Not a constructor call inline def nonMatchingIsNone: Boolean = ${ Macro.nonMatchingIsNoneImpl } - // Same field count as `Point`, but a different type: arity alone must not be enough. + // Same arity, wrong type inline def wrongTypeIsNone: Boolean = ${ Macro.wrongTypeIsNoneImpl } - // A `Circle` tree read back as a `Rect`: same sum type, wrong variant. + // Wrong sum variant inline def wrongSumVariantIsNone: Boolean = ${ Macro.wrongSumVariantIsNoneImpl } - // A 2-element tuple (from a `Point`'s `fromProduct` call) read back as a `Mixed` - // (arity 3): the tuple-unwrap branch must reject the arity mismatch, not crash. + // Wrong arity inline def wrongArityIsNone: Boolean = ${ Macro.wrongArityIsNoneImpl } - // `Big25`'s `ToExpr.derived` output uses the `Tuple.fromIArray(...)` shape (arity > 22), - // which the tuple-unwrap branch doesn't recognize -- a documented limitation, not a - // crash. + // Arity > 22, documented limitation inline def roundTripBig25IsNone: Boolean = ${ Macro.roundTripBig25IsNoneImpl } - // A `Meters`-shaped `fromProduct` tree read back as `Seconds`: same arity, same field - // type, so only the receiver-mirror check (not field-level extraction) can catch this. + // Wrong mirror, same arity/field type inline def wrongMirrorIsNone: Boolean = ${ Macro.wrongMirrorIsNoneImpl } - // `derived` applied directly to a tuple type: matches a literal tuple-literal quote - // (arity 2), and round-trips through `ToExpr.derived` at a higher arity (5). + // `derived` on a tuple type directly inline def matchTuple2: Boolean = ${ Macro.matchTuple2Impl } inline def roundTripTuple5: Boolean = ${ Macro.roundTripTuple5Impl } - // Round trip: a value lifted to code via `ToExpr.derived` must be readable back via - // `FromExpr.derived` on the same type. `ToExpr.derived` always produces a - // `mirror.fromProduct(tuple)`-shaped tree (never a `T(args*)`/`new T(args*)` call), so - // this exercises the dedicated recognition branch for that shape: a product at several - // arities, a singleton (both a real case object and a `TermRef`-encoded enum case), a - // zero-arg non-singleton, a sum type, a generic type, and a product with a sum-typed - // field (composing the recognition recursively). + // ToExpr.derived -> FromExpr.derived round trip, all cases above inline def roundTrips: Boolean = ${ Macro.roundTripsImpl } - // Shared by (almost) every scenario above: extract `expr` via `T`'s `FromExpr` and - // compare against the value it's expected to produce (or, for `checkNone`, expect - // extraction to fail). Factored out since the comparison itself is always the same -- - // only the quoted syntax and type under test vary per scenario. private def check[T: Type: FromExpr](expr: Expr[T], expected: T)(using Quotes): Expr[Boolean] = Expr(summon[FromExpr[T]].unapply(expr) == Some(expected)) @@ -246,9 +176,6 @@ object Macro: check[Vehicle]('{ Vehicle.Bicycle(21) }, Vehicle.Bicycle(21)) def wrongNestedVariantIsNoneImpl(using Quotes): Expr[Boolean] = - // `Car`/`Motorcycle` no longer have their own top-level `FromExpr` (they're derived - // automatically as part of `Vehicle`'s own dispatch, not exposed standalone), so derive - // one locally just to check this specific leaf-to-leaf mismatch. given FromExpr[Vehicle.Motorized.Motorcycle] = FromExpr.derived val e: Expr[Vehicle.Motorized.Car] = '{ Vehicle.Motorized.Car(4) } checkNone(e.asInstanceOf[Expr[Vehicle.Motorized.Motorcycle]]) @@ -264,7 +191,6 @@ object Macro: checkNone(e.asInstanceOf[Expr[Address]]) def wrongSumVariantIsNoneImpl(using Quotes): Expr[Boolean] = - // `Rect` no longer has its own top-level `FromExpr` (see `wrongNestedVariantIsNoneImpl`). given FromExpr[Shape.Rect] = FromExpr.derived val e: Expr[Shape.Circle] = '{ Shape.Circle(1.0) } checkNone(e.asInstanceOf[Expr[Shape.Rect]]) diff --git a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala index 47e188cd0905..f744194b4f9a 100644 --- a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala @@ -1,75 +1,53 @@ import scala.quoted.* -// Product derivation: plain case class with primitive fields. +// Plain product, primitives case class Point(x: Int, y: Int) derives ToExpr -// Product derivation: nested case classes (field itself has a derived ToExpr), and the -// case class itself is nested inside another object's companion. +// Nested products, cross-object case class Address(city: String, zip: Int) derives ToExpr object Namespace: case class Person(name: String, address: Address) derives ToExpr -// Product derivation: case object (singleton), reconstructed via `Mirror.fromProduct` -// applied to `EmptyTuple`. +// Singleton (case object) case object Singleton derives ToExpr -// Product derivation: generic case class. `derives` only adds a `ToExpr[A]` bound to -// the generated given, not `Type[A]`, so a plain `derives ToExpr` clause on a generic -// class doesn't compile (the derived code needs to mention `A` inside a quote). Adding -// an explicit given with both bounds works. +// Generic product (needs an explicit Type/instance bound) case class Box[A](value: A) -given boxToExpr[A: Type: ToExpr]: ToExpr[Box[A]] = ToExpr.derived +given [A: {Type, ToExpr}] => ToExpr[Box[A]] = ToExpr.derived -// Product derivation: case class with a variety of primitive field kinds. +// Product, mixed field kinds case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExpr -// Product derivation with a field type (`List[Int]`) whose `ToExpr` instance itself -// needs a `Type[Int]` (via `ListToExpr[T: Type: ToExpr]`), which can only be summoned -// where a `Quotes` is already ambient -- unlike the generic case above, adding a plain -// `Type`/`ToExpr` bound to the given doesn't help here (there's no type parameter to -// bind it to), so the given needs to be conditional on `Quotes` directly. +// Field type (List[Int]) whose ToExpr needs Quotes ambient, not just Type/instance case class Tagged(tags: List[Int]) given taggedToExpr(using Quotes): ToExpr[Tagged] = ToExpr.derived -// Sum derivation: sealed hierarchy of case classes and case objects, nested inside the -// sealed trait's own companion object. Only the sealed trait itself needs `derives` -- its -// own cases are derived automatically since none of them already has an instance in scope; -// the sum's derived instance just dispatches by ordinal to whichever case it picks up. +// Sum: sealed trait + cases, auto-derived sealed trait Shape derives ToExpr object Shape: case class Circle(r: Double) extends Shape case class Rect(w: Double, h: Double) extends Shape case object Origin extends Shape -// Sum derivation over an enum with a mix of singleton and parameterized cases. Only the -// enum itself needs `derives` -- its cases are derived automatically, the same as `Shape`. +// Sum: enum, singleton + parameterized cases enum Color derives ToExpr: case Red, Green case Custom(hex: String) -// Product derivation with a sum-typed field: composes `derivedProduct` (for `Container`) -// and `derivedSum` (for its `shape` field) within a single derivation. +// Product with a sum-typed field case class Container(name: String, shape: Shape) derives ToExpr -// Product derivation: zero-arg case class. Distinct from a singleton (`Singleton` above): -// this still goes through the constructor-call machinery, `fromProduct` is just applied -// to an already-empty tuple because the class happens to have no fields. +// Zero-arg product (not a singleton) case class Blank() derives ToExpr -// Sum derivation over a generic sealed trait: combines the generics-need-an-explicit-given -// constraint (see `Box` above) with sum dispatch (see `Shape` above). The sealed trait -// itself still needs the explicit `Type[A]`/instance-bound given, but its cases (`Ok`, -// `Fail`) no longer need one of their own -- `A`'s own bound is already in scope from the -// outer given. +// Generic sum (explicit bound on the trait; cases auto-derived) sealed trait Result[+A] object Result: case class Ok[A](value: A) extends Result[A] case object Fail extends Result[Nothing] +given [A: {Type, ToExpr}] => ToExpr[Result[A]] = ToExpr.derived -given resultToExpr[A: Type: ToExpr]: ToExpr[Result[A]] = ToExpr.derived - -// ConstToExpr: an arbitrary (non-case) object singleton type, lifted directly via -// `valueOf[T]`, found by ordinary implicit search (no `derives` involved at all). +// Non-case singleton, lifted via valueOf[T] (no `derives`) object Marker object Macro: @@ -94,9 +72,7 @@ object Macro: inline def liftResultOk: Result[Int] = ${ Macro.liftResultOkImpl } inline def liftResultFail: Result[Int] = ${ Macro.liftResultFailImpl } - // Regression guard: the generated code for a derived product must stay a plain - // `mirror.fromProduct(tuple)` call -- not silently regress into something that stages - // reflection (`getClass`, `Symbol.requiredClass`, ...) into the generated tree itself. + // Regression guard: derived code stays a plain `mirror.fromProduct(tuple)` call inline def showPointTree: String = ${ Macro.showPointTreeImpl } def liftPointImpl(using Quotes): Expr[Point] = Expr(Point(1, 2)) @@ -108,9 +84,7 @@ object Macro: def liftMixedImpl(using Quotes): Expr[Mixed] = Expr(Mixed("m", true, 1.5)) def liftTaggedImpl(using Quotes): Expr[Tagged] = Expr(Tagged(List(1, 2, 3))) def liftCircleImpl(using Quotes): Expr[Shape.Circle] = - // `Circle` no longer has its own top-level `ToExpr` (it's derived automatically as part - // of `Shape`'s own dispatch, not exposed standalone), so derive one locally to lift it - // directly (as opposed to `liftShapeCircleImpl` below, which goes through `Shape`). + // `Circle` has no standalone top-level `ToExpr` (auto-derived via `Shape`), so derive locally given ToExpr[Shape.Circle] = ToExpr.derived Expr(Shape.Circle(1.0)) def liftShapeCircleImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Circle(2.0)) From 9f3356ac7c45a70e38d52f8b5c03dfb485e63efc Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 12:33:41 +0200 Subject: [PATCH 05/17] use lazy val for elemInstances in FromExpr and ToExpr derivations to allow recursive derivation --- library/src/scala/quoted/FromExpr.scala | 19 +++++++++++-------- library/src/scala/quoted/ToExpr.scala | 13 ++++++++----- .../Macro_1.scala | 17 +++++++++++++++-- .../Test_2.scala | 1 + 4 files changed, 35 insertions(+), 15 deletions(-) diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index afc5e522d64a..6d937e531f33 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -49,7 +49,9 @@ object FromExpr { case given Mirror.Of[C] => derived[C] @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] - private inline def derivedProduct[T: Mirror.ProductOf as m](elemInstances: List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: + private inline def derivedProduct[T: Mirror.ProductOf as m](elemInstances: -> List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: + private lazy val elems = elemInstances + def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = import quotes.reflect.* val tpe = TypeRepr.of[T] @@ -68,30 +70,31 @@ object FromExpr { // defn.TupleClass does not work :/ def tupleModuleClass = - Symbol.requiredModule(if elemInstances.isEmpty then "scala.Tuple" else s"scala.Tuple${elemInstances.length}").moduleClass + Symbol.requiredModule(if elems.isEmpty then "scala.Tuple" else s"scala.Tuple${elems.length}").moduleClass - def extractArgs(args: List[Term]): Option[T] = elemInstances.zip(args).foldRight(Option(List.empty[Any])): + def extractArgs(args: List[Term]): Option[T] = elems.zip(args).foldRight(Option(List.empty[Any])): case (_, None) => None case ((fe, arg), Some(acc)) => fe.unapply(arg.asExprOf[Any]).map(_ :: acc) .map(vs => m.fromProduct(Tuple.fromArray(vs.toArray))) stripWrappers(x.asTerm) match - case Apply(fun, args) if args.length == elemInstances.length && isOwnConstructor(fun) => + case Apply(fun, args) if args.length == elems.length && isOwnConstructor(fun) => extractArgs(args) // case '{ type tuple <: Tuple; { $mirror : Mirror.ProductOf[T] }.fromProduct($tuple : tuple ) } => on x does not work :/ case Apply(Select(recv, "fromProduct"), List(tupleArg)) if recv.tpe <:< TypeRepr.of[Mirror.ProductOf[T]] => stripWrappers(tupleArg) match - case Apply(fun, args) if fun.symbol.name == "apply" && fun.symbol.owner == tupleModuleClass && args.length == elemInstances.length => extractArgs(args) + case Apply(fun, args) if fun.symbol.name == "apply" && fun.symbol.owner == tupleModuleClass && args.length == elems.length => extractArgs(args) case _ => None // A bare reference to a singleton (case object/enum case), not a call. TermRef for an explicit given/enum case, TypeRef (via companion) for `derives`. - case t if elemInstances.isEmpty && t.symbol == (if tpe.termSymbol.exists then tpe.termSymbol else sym.companionModule) => + case t if elems.isEmpty && t.symbol == (if tpe.termSymbol.exists then tpe.termSymbol else sym.companionModule) => Some(m.fromProduct(EmptyTuple)) case _ => None - private def derivedSum[T: Mirror.SumOf](elemInstances: List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: + private def derivedSum[T: Mirror.SumOf](elemInstances: -> List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: + private lazy val elems = elemInstances def unapply(x: Expr[T])(using Quotes): Option[T] = - elemInstances.iterator.map(_.unapply(x.asInstanceOf[Expr[Any]])).collectFirst { case Some(v) => v.asInstanceOf[T] } + elems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } /** Default implementation of `FromExpr[Boolean]` diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index c7ee1a5f9747..97f02a41ba1c 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -27,7 +27,7 @@ object ToExpr { import scala.quoted.* inline def derived[T: Mirror.Of as m]: ToExpr[T] = inline m match - case given Mirror.ProductOf[T] => + case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExpr]].toList.asInstanceOf[List[ToExpr[Any]]]) case given Mirror.SumOf[T] => derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) @@ -41,16 +41,19 @@ object ToExpr { case given Mirror.Of[C] => derived[C] @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] - private inline def derivedProduct[T: Mirror.ProductOf](elemInstances: List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: + private inline def derivedProduct[T: Mirror.ProductOf](elemInstances: -> List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: + private lazy val elems = elemInstances + def apply(x: T)(using Quotes): Expr[T] = val mirrorExpr = Expr.summon[Mirror.ProductOf[T]].get val elemVals = x.asInstanceOf[Product].productIterator.toList - val elemExprs = elemInstances.zip(elemVals).map(_.apply(_)) + val elemExprs = elems.zip(elemVals).map(_.apply(_)) val tupleExpr = Expr.ofTupleFromSeq(elemExprs) '{ $mirrorExpr.fromProduct($tupleExpr) } - private def derivedSum[T: Mirror.SumOf as m](elemInstances: List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: - def apply(x: T)(using Quotes): Expr[T] = elemInstances(m.ordinal(x)).apply(x).asInstanceOf[Expr[T]] + private def derivedSum[T: Mirror.SumOf as m](elemInstances: -> List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: + private lazy val elems = elemInstances + def apply(x: T)(using Quotes): Expr[T] = elems(m.ordinal(x)).apply(x).asInstanceOf[Expr[T]] // IMPORTANT Keep in sync with tests/run-staging/liftables.scala given ValueOfToExpr: [T: {ValueOf, Type}] => ToExpr[T]: diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala index b678a62ef9e0..96c72ea206f3 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -67,8 +67,11 @@ object Vehicle: case class Motorcycle(cc: Int) extends Motorized case class Bicycle(gears: Int) extends Vehicle -// NOTE: a genuinely recursive sum (e.g. `Add(l: Arith, r: Arith)`) deadlocks during -// derivation (circular top-level given initialization) -- out of scope, see SLC. +// Recursive sum: a case's own field is the enclosing type +enum Arith derives ToExpr, FromExpr: + case Lit(n: Int) + case Add(l: Arith, r: Arith) + case Neg(e: Arith) // Arity > 22 (known limitation, not a crash) case class Big25( @@ -105,6 +108,9 @@ object Macro: // Nested-sum wrong-variant guard inline def wrongNestedVariantIsNone: Boolean = ${ Macro.wrongNestedVariantIsNoneImpl } + // Recursive ADT, several levels deep + inline def matchArithNested: Boolean = ${ Macro.matchArithNestedImpl } + // `Typed` node unwrapping inline def matchAscribedPoint: Boolean = ${ Macro.matchAscribedPointImpl } @@ -180,6 +186,12 @@ object Macro: val e: Expr[Vehicle.Motorized.Car] = '{ Vehicle.Motorized.Car(4) } checkNone(e.asInstanceOf[Expr[Vehicle.Motorized.Motorcycle]]) + def matchArithNestedImpl(using Quotes): Expr[Boolean] = + check[Arith]( + '{ Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3)))) }, + Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3)))) + ) + def matchAscribedPointImpl(using Quotes): Expr[Boolean] = check('{ (Point(1, 2): Point) }, Point(1, 2)) def matchBracedPointImpl(using Quotes): Expr[Boolean] = check('{ { Point(1, 2) } }, Point(1, 2)) @@ -232,4 +244,5 @@ object Macro: && roundTrip[Color](Color.Custom("#fff")) && roundTrip[Vehicle](Vehicle.Motorized.Car(4)) && roundTrip[Vehicle](Vehicle.Bicycle(21)) + && roundTrip(Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3))))) ) diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala index 88e0b85d2f1f..0c684f8122e6 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala @@ -23,6 +23,7 @@ object Test: assert(Macro.matchVehicleMotorcycle, "matchVehicleMotorcycle") assert(Macro.matchVehicleBicycle, "matchVehicleBicycle") assert(Macro.wrongNestedVariantIsNone, "wrongNestedVariantIsNone") + assert(Macro.matchArithNested, "matchArithNested") assert(Macro.matchAscribedPoint, "matchAscribedPoint") assert(Macro.matchBracedPoint, "matchBracedPoint") assert(Macro.nonMatchingIsNone, "nonMatchingIsNone") From 9331e0fbaef5c2fe37c868c071d9306bd54a0976 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 16:37:23 +0200 Subject: [PATCH 06/17] Add FromExprFactory and ToExprFactory for type constructors --- library/src/scala/quoted/FromExpr.scala | 61 ++---------------- .../src/scala/quoted/FromExprFactory.scala | 53 ++++++++++++++++ library/src/scala/quoted/InternalUtils.scala | 63 +++++++++++++++++++ library/src/scala/quoted/ToExpr.scala | 23 ++----- library/src/scala/quoted/ToExprFactory.scala | 48 ++++++++++++++ 5 files changed, 175 insertions(+), 73 deletions(-) create mode 100644 library/src/scala/quoted/FromExprFactory.scala create mode 100644 library/src/scala/quoted/InternalUtils.scala create mode 100644 library/src/scala/quoted/ToExprFactory.scala diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index 6d937e531f33..05b516e1af06 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -29,8 +29,9 @@ trait FromExpr[T] { } + /** Default given instances of `FromExpr`. */ -object FromExpr { +object FromExpr extends LowPriorityFromExpr: import scala.deriving.Mirror @@ -38,64 +39,16 @@ object FromExpr { case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExpr]].toList.asInstanceOf[List[FromExpr[Any]]]) case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) - - private inline def summonAllOrDerive[Elems <: Tuple]: List[FromExpr[Any]] = inline compiletime.erasedValue[Elems] match - case _: EmptyTuple => Nil - case _: (h *: t) => summonOrDerive[h].asInstanceOf[FromExpr[Any]] :: summonAllOrDerive[t] - - private inline def summonOrDerive[C]: FromExpr[C] = compiletime.summonFrom: - case fe: FromExpr[C] => fe - case given Mirror.Of[C] => derived[C] + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, FromExpr]([A] => () => derived[A])) @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] - private inline def derivedProduct[T: Mirror.ProductOf as m](elemInstances: -> List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: + private inline def derivedProduct[T: Mirror.ProductOf as m](elemInstances: => List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: private lazy val elems = elemInstances - - def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = - import quotes.reflect.* - val tpe = TypeRepr.of[T] - val sym = tpe.typeSymbol - - @tailrec def stripWrappers(t: Term): Term = t match - case Inlined(_, Nil, e) => stripWrappers(e) - case Block(Nil, e) => stripWrappers(e) - case Typed(e, _) => stripWrappers(e) - case _ => t - - // `new T(args*)` (primary ctor) or `T(args*)` (companion `apply`). - def isOwnConstructor(fun: Term): Boolean = - fun.symbol == sym.primaryConstructor - || (fun.symbol.name == "apply" && fun.symbol.owner == sym.companionModule.moduleClass) - - // defn.TupleClass does not work :/ - def tupleModuleClass = - Symbol.requiredModule(if elems.isEmpty then "scala.Tuple" else s"scala.Tuple${elems.length}").moduleClass - - def extractArgs(args: List[Term]): Option[T] = elems.zip(args).foldRight(Option(List.empty[Any])): - case (_, None) => None - case ((fe, arg), Some(acc)) => - fe.unapply(arg.asExprOf[Any]).map(_ :: acc) - .map(vs => m.fromProduct(Tuple.fromArray(vs.toArray))) - - stripWrappers(x.asTerm) match - case Apply(fun, args) if args.length == elems.length && isOwnConstructor(fun) => - extractArgs(args) - // case '{ type tuple <: Tuple; { $mirror : Mirror.ProductOf[T] }.fromProduct($tuple : tuple ) } => on x does not work :/ - case Apply(Select(recv, "fromProduct"), List(tupleArg)) if recv.tpe <:< TypeRepr.of[Mirror.ProductOf[T]] => - stripWrappers(tupleArg) match - case Apply(fun, args) if fun.symbol.name == "apply" && fun.symbol.owner == tupleModuleClass && args.length == elems.length => extractArgs(args) - case _ => None - // A bare reference to a singleton (case object/enum case), not a call. TermRef for an explicit given/enum case, TypeRef (via companion) for `derives`. - case t if elems.isEmpty && t.symbol == (if tpe.termSymbol.exists then tpe.termSymbol else sym.companionModule) => - Some(m.fromProduct(EmptyTuple)) - case _ => None + def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = unapplyProduct[T](elems)(x) private def derivedSum[T: Mirror.SumOf](elemInstances: -> List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: private lazy val elems = elemInstances - def unapply(x: Expr[T])(using Quotes): Option[T] = - elems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } - + def unapply(x: Expr[T])(using Quotes): Option[T] = unapplySum[T](elems)(x) /** Default implementation of `FromExpr[Boolean]` * - Transform `'{true}` into `Some(true)` @@ -603,5 +556,3 @@ object FromExpr { case _ => None } } - -} diff --git a/library/src/scala/quoted/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala new file mode 100644 index 000000000000..8b1e2fffb5b0 --- /dev/null +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -0,0 +1,53 @@ +package scala.quoted + +import language.experimental.captureChecking +import scala.deriving.Mirror + +/** A factory that, given a `Type[T]`, produces a `FromExpr[T]`. + * + * Like `ToExprFactory`, routes each field/case through `FromExprFactory` recursively, so + * `derives FromExprFactory` on a generic type does not require a manual + * `given [A: {Type, FromExpr}] => FromExpr[Box[A]]` for its type parameters. + */ +trait FromExprFactory[T]: + def apply()(using Type[T]): FromExpr[T] + +object FromExprFactory: + inline def derived[T: Mirror.Of as m]: FromExprFactory[T] = inline m match + case given Mirror.ProductOf[T] => + derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExprFactory]].toList.asInstanceOf[List[FromExprFactory[Any]]]) + case given Mirror.SumOf[T] => + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, FromExprFactory]([A] => () => derived[A])) + + private def derivedProduct[T: Mirror.ProductOf as m](elemInstances: -> List[FromExprFactory[Any]]): FromExprFactory[T] = new FromExprFactory[T]: + private lazy val elems = elemInstances + def apply()(using Type[T]): FromExpr[T] = new FromExpr[T]: + def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = + import quotes.reflect.* + val tpe = TypeRepr.of[T] + val fieldSyms = tpe.typeSymbol.caseFields + val resolvedElems = elems.zip(fieldSyms).map: + case (factory, fieldSym) => + tpe.memberType(fieldSym).asType match + case '[t] => factory.asInstanceOf[FromExprFactory[t]].apply().asInstanceOf[FromExpr[Any]] + + unapplyProduct[T](resolvedElems)(x) + + private def derivedSum[T: Mirror.SumOf](elemInstances: -> List[FromExprFactory[Any]]): FromExprFactory[T] = new FromExprFactory[T]: + private lazy val elems = elemInstances + def apply()(using Type[T]): FromExpr[T] = new FromExpr[T]: + def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = + import quotes.reflect.* + val caseSyms = TypeRepr.of[T].typeSymbol.children + val resolvedElems: List[FromExpr[Any]] = elems.zip(caseSyms).map: + case (factory, caseSym) => + caseSym.typeRef.asType match + case '[c] => factory.asInstanceOf[FromExprFactory[c]].apply().asInstanceOf[FromExpr[Any]] + unapplySum[T](resolvedElems)(x) + + /** Bridges any type that already has a plain `FromExpr` (e.g. `Int`, `String`) into `FromExprFactory`. */ + given [T] => (fe: FromExpr[T]) => FromExprFactory[T]: + def apply()(using Type[T]): FromExpr[T] = fe + +private[quoted] trait LowPriorityFromExpr: + given [T: Type] => (f: FromExprFactory[T]) => FromExpr[T] = f.apply() diff --git a/library/src/scala/quoted/InternalUtils.scala b/library/src/scala/quoted/InternalUtils.scala new file mode 100644 index 000000000000..439b94208b0f --- /dev/null +++ b/library/src/scala/quoted/InternalUtils.scala @@ -0,0 +1,63 @@ +package scala.quoted + +import scala.annotation.tailrec +import scala.deriving.Mirror +import scala.quoted.{Expr, Quotes, Type} + +private[quoted] def unapplyProduct[T: {Type, Mirror.ProductOf as m}](using quotes: Quotes)(elems: List[FromExpr[Any]])(x: Expr[T]): Option[T] = + import quotes.reflect.* + val tpe = TypeRepr.of[T] + val sym = tpe.typeSymbol + + @tailrec def stripWrappers(t: Term): Term = t match + case Inlined(_, Nil, e) => stripWrappers(e) + case Block(Nil, e) => stripWrappers(e) + case Typed(e, _) => stripWrappers(e) + case _ => t + + // `new T(args*)` (primary ctor) or `T(args*)` (companion `apply`). + def isOwnConstructor(fun: Term): Boolean = + fun.symbol == sym.primaryConstructor + || (fun.symbol.name == "apply" && fun.symbol.owner == sym.companionModule.moduleClass) + + // defn.TupleClass does not work :/ + def tupleModuleClass = + Symbol.requiredModule(if elems.isEmpty then "scala.Tuple" else s"scala.Tuple${elems.size}").moduleClass + + def extractArgs(args: List[Term]) = elems.zip(args).foldRight(Option(List.empty[Any])): + case (_, None) => None + case ((fe, arg), Some(acc)) => fe.unapply(arg.asExprOf[Any]).map(_ :: acc) + + val args = stripWrappers(x.asTerm) match + case Apply(fun, args) if args.length == elems.size && isOwnConstructor(fun) => + extractArgs(args) + // case '{ type tuple <: Tuple; { $mirror : Mirror.ProductOf[T] }.fromProduct($tuple : tuple ) } => on x does not work :/ + case Apply(Select(recv, "fromProduct"), List(tupleArg)) if recv.tpe <:< TypeRepr.of[deriving.Mirror.ProductOf[T]] => + stripWrappers(tupleArg) match + case Apply(fun, args) + if fun.symbol.name == "apply" && fun.symbol.owner == tupleModuleClass && args.length == elems.size => + extractArgs(args) + case _ => None + // A bare reference to a singleton (case object/enum case), not a call. TermRef for an explicit given/enum case, TypeRef (via companion) for `derives`. + case t if elems.isEmpty && t.symbol == (if tpe.termSymbol.exists then tpe.termSymbol else sym.companionModule) => + extractArgs(Nil) + case _ => None + + args.map(vs => m.fromProduct(Tuple.fromArray(vs.toArray))) + +private[quoted] def unapplySum[T](elems: List[FromExpr[Any]])(x: Expr[T])(using Quotes): Option[T] = + elems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } +private[quoted] def applyProduct[T: Type](elems: List[ToExpr[Any]])(x: T)(using Quotes): Expr[T] = + val mirrorExpr = Expr.summon[Mirror.ProductOf[T]].get + val elemVals = x.asInstanceOf[Product].productIterator.toList + val elemExprs = elems.zip(elemVals).map(_.apply(_)) + val tupleExpr = Expr.ofTupleFromSeq(elemExprs) + '{ $mirrorExpr.fromProduct($tupleExpr) } + +private[quoted] inline def summonAllOrDerive[Elems <: Tuple, F[_]](inline derived: [A:Mirror.Of] => () => F[A]): List[F[Any]] = inline compiletime.erasedValue[Elems] match + case _: EmptyTuple => Nil + case _: (h *: t) => summonOrDerive[h, F](derived).asInstanceOf[F[Any]] :: summonAllOrDerive[t, F](derived) + +private[quoted] inline def summonOrDerive[T, F[_]](inline derived: [A:Mirror.Of] => () => F[A]): F[T] = compiletime.summonFrom: + case te: F[T] => te + case given Mirror.Of[T] => derived[T]() \ No newline at end of file diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 97f02a41ba1c..bdaa3a5a22bc 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -21,39 +21,26 @@ trait ToExpr[T] { } /** Default given instances of `ToExpr`. */ -object ToExpr { +object ToExpr extends LowPriorityToExpr { import scala.deriving.Mirror - import scala.quoted.* inline def derived[T: Mirror.Of as m]: ToExpr[T] = inline m match case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExpr]].toList.asInstanceOf[List[ToExpr[Any]]]) - case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) - - private inline def summonAllOrDerive[Elems <: Tuple]: List[ToExpr[Any]] = inline compiletime.erasedValue[Elems] match - case _: EmptyTuple => Nil - case _: (h *: t) => summonOrDerive[h].asInstanceOf[ToExpr[Any]] :: summonAllOrDerive[t] - - private inline def summonOrDerive[C]: ToExpr[C] = compiletime.summonFrom: - case te: ToExpr[C] => te - case given Mirror.Of[C] => derived[C] + case given Mirror.SumOf[T] => + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, ToExpr]([A] => () => derived[A])) @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] private inline def derivedProduct[T: Mirror.ProductOf](elemInstances: -> List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: private lazy val elems = elemInstances - def apply(x: T)(using Quotes): Expr[T] = - val mirrorExpr = Expr.summon[Mirror.ProductOf[T]].get - val elemVals = x.asInstanceOf[Product].productIterator.toList - val elemExprs = elems.zip(elemVals).map(_.apply(_)) - val tupleExpr = Expr.ofTupleFromSeq(elemExprs) - '{ $mirrorExpr.fromProduct($tupleExpr) } + def apply(x: T)(using Quotes): Expr[T] = applyProduct(elems)(x) private def derivedSum[T: Mirror.SumOf as m](elemInstances: -> List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: private lazy val elems = elemInstances def apply(x: T)(using Quotes): Expr[T] = elems(m.ordinal(x)).apply(x).asInstanceOf[Expr[T]] + // IMPORTANT Keep in sync with tests/run-staging/liftables.scala given ValueOfToExpr: [T: {ValueOf, Type}] => ToExpr[T]: diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala new file mode 100644 index 000000000000..7ed797d4b732 --- /dev/null +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -0,0 +1,48 @@ +package scala.quoted + +import language.experimental.captureChecking +import scala.deriving.Mirror + +/** A factory that, given a `Type[T]`, produces a `ToExpr[T]`. + * + * Unlike `ToExpr.derived`, `ToExprFactory.derived` also routes each field/case through + * `ToExprFactory` recursively, so `derives ToExprFactory` on a generic type does not + * require a manual `given [A: {Type, ToExpr}] => ToExpr[Box[A]]` for its type parameters. + */ +trait ToExprFactory[T]: + def apply()(using Type[T]): ToExpr[T] + +object ToExprFactory: + inline def derived[T: Mirror.Of as m]: ToExprFactory[T] = inline m match + case given Mirror.ProductOf[T] => + derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExprFactory]].toList.asInstanceOf[List[ToExprFactory[Any]]]) + case given Mirror.SumOf[T] => + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, ToExprFactory]([A] => () => derived[A])) + + private def derivedProduct[T: Mirror.ProductOf](elemInstances: -> List[ToExprFactory[Any]]): ToExprFactory[T] = new ToExprFactory[T]: + private lazy val elems = elemInstances + def apply()(using Type[T]): ToExpr[T] = new ToExpr[T]: + def apply(x: T)(using Quotes): Expr[T] = + import quotes.reflect.* + val tpe = TypeRepr.of[T] + val fieldSyms = tpe.typeSymbol.caseFields + val resolvedElems: List[ToExpr[Any]] = elems.zip(fieldSyms).map: + case (factory, fieldSym) => + tpe.memberType(fieldSym).asType match + case '[t] => factory.asInstanceOf[ToExprFactory[t]].apply().asInstanceOf[ToExpr[Any]] + applyProduct[T](resolvedElems)(x) + + private def derivedSum[T: Mirror.SumOf as m](elemInstances: -> List[ToExprFactory[Any]]): ToExprFactory[T] = new ToExprFactory[T]: + private lazy val elems = elemInstances + def apply()(using Type[T]): ToExpr[T] = new ToExpr[T]: + def apply(x: T)(using Quotes): Expr[T] = + import quotes.reflect.* + TypeRepr.typeConstructorOf(x.getClass).asType match + case '[c] => elems(m.ordinal(x)).asInstanceOf[ToExprFactory[c]].apply().apply(x.asInstanceOf[c]).asInstanceOf[Expr[T]] + + /** Bridges any type that already has a plain `ToExpr` (e.g. `Int`, `String`) into `ToExprFactory`. */ + given [T] => (te: ToExpr[T]) => ToExprFactory[T]: + def apply()(using Type[T]): ToExpr[T] = te + +private[quoted] trait LowPriorityToExpr: + given [T: Type] => (f: ToExprFactory[T]) => ToExpr[T] = f.apply() From 8a8136cc22ce9d3146c8317e608f9ac74ca46497 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 16:51:50 +0200 Subject: [PATCH 07/17] revert copy-pasted derivation mechanisms --- library/src/scala/quoted/FromExpr.scala | 10 +++++++++- library/src/scala/quoted/FromExprFactory.scala | 10 +++++++++- library/src/scala/quoted/InternalUtils.scala | 10 +--------- library/src/scala/quoted/ToExpr.scala | 10 +++++++++- library/src/scala/quoted/ToExprFactory.scala | 10 +++++++++- 5 files changed, 37 insertions(+), 13 deletions(-) diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index 05b516e1af06..96b427139140 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -39,7 +39,15 @@ object FromExpr extends LowPriorityFromExpr: case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExpr]].toList.asInstanceOf[List[FromExpr[Any]]]) case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, FromExpr]([A] => () => derived[A])) + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) + + private inline def summonAllOrDerive[Elems <: Tuple]: List[FromExpr[Any]] = inline compiletime.erasedValue[Elems] match + case _: EmptyTuple => Nil + case _: (h *: t) => summonOrDerive[h].asInstanceOf[FromExpr[Any]] :: summonAllOrDerive[t] + + private inline def summonOrDerive[T]: FromExpr[T] = compiletime.summonFrom: + case fe: FromExpr[T] => fe + case given Mirror.Of[T] => derived[T] @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] private inline def derivedProduct[T: Mirror.ProductOf as m](elemInstances: => List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: diff --git a/library/src/scala/quoted/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala index 8b1e2fffb5b0..9e93d27dac68 100644 --- a/library/src/scala/quoted/FromExprFactory.scala +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -17,7 +17,15 @@ object FromExprFactory: case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExprFactory]].toList.asInstanceOf[List[FromExprFactory[Any]]]) case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, FromExprFactory]([A] => () => derived[A])) + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) + + private inline def summonAllOrDerive[Elems <: Tuple]: List[FromExprFactory[Any]] = inline compiletime.erasedValue[Elems] match + case _: EmptyTuple => Nil + case _: (h *: t) => summonOrDerive[h].asInstanceOf[FromExprFactory[Any]] :: summonAllOrDerive[t] + + private inline def summonOrDerive[T]: FromExprFactory[T] = compiletime.summonFrom: + case fe: FromExprFactory[T] => fe + case given Mirror.Of[T] => derived[T] private def derivedProduct[T: Mirror.ProductOf as m](elemInstances: -> List[FromExprFactory[Any]]): FromExprFactory[T] = new FromExprFactory[T]: private lazy val elems = elemInstances diff --git a/library/src/scala/quoted/InternalUtils.scala b/library/src/scala/quoted/InternalUtils.scala index 439b94208b0f..7da9b4c93f86 100644 --- a/library/src/scala/quoted/InternalUtils.scala +++ b/library/src/scala/quoted/InternalUtils.scala @@ -52,12 +52,4 @@ private[quoted] def applyProduct[T: Type](elems: List[ToExpr[Any]])(x: T)(using val elemVals = x.asInstanceOf[Product].productIterator.toList val elemExprs = elems.zip(elemVals).map(_.apply(_)) val tupleExpr = Expr.ofTupleFromSeq(elemExprs) - '{ $mirrorExpr.fromProduct($tupleExpr) } - -private[quoted] inline def summonAllOrDerive[Elems <: Tuple, F[_]](inline derived: [A:Mirror.Of] => () => F[A]): List[F[Any]] = inline compiletime.erasedValue[Elems] match - case _: EmptyTuple => Nil - case _: (h *: t) => summonOrDerive[h, F](derived).asInstanceOf[F[Any]] :: summonAllOrDerive[t, F](derived) - -private[quoted] inline def summonOrDerive[T, F[_]](inline derived: [A:Mirror.Of] => () => F[A]): F[T] = compiletime.summonFrom: - case te: F[T] => te - case given Mirror.Of[T] => derived[T]() \ No newline at end of file + '{ $mirrorExpr.fromProduct($tupleExpr) } \ No newline at end of file diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index bdaa3a5a22bc..e412f9db70ba 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -29,7 +29,15 @@ object ToExpr extends LowPriorityToExpr { case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExpr]].toList.asInstanceOf[List[ToExpr[Any]]]) case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, ToExpr]([A] => () => derived[A])) + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) + + private inline def summonAllOrDerive[Elems <: Tuple]: List[ToExpr[Any]] = inline compiletime.erasedValue[Elems] match + case _: EmptyTuple => Nil + case _: (h *: t) => summonOrDerive[h].asInstanceOf[ToExpr[Any]] :: summonAllOrDerive[t] + + private inline def summonOrDerive[T]: ToExpr[T] = compiletime.summonFrom: + case te: ToExpr[T] => te + case given Mirror.Of[T] => derived[T] @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] private inline def derivedProduct[T: Mirror.ProductOf](elemInstances: -> List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index 7ed797d4b732..3a3940366072 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -17,7 +17,15 @@ object ToExprFactory: case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExprFactory]].toList.asInstanceOf[List[ToExprFactory[Any]]]) case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes, ToExprFactory]([A] => () => derived[A])) + derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) + + private inline def summonAllOrDerive[Elems <: Tuple]: List[ToExprFactory[Any]] = inline compiletime.erasedValue[Elems] match + case _: EmptyTuple => Nil + case _: (h *: t) => summonOrDerive[h].asInstanceOf[ToExprFactory[Any]] :: summonAllOrDerive[t] + + private inline def summonOrDerive[T]: ToExprFactory[T] = compiletime.summonFrom: + case te: ToExprFactory[T] => te + case given Mirror.Of[T] => derived[T] private def derivedProduct[T: Mirror.ProductOf](elemInstances: -> List[ToExprFactory[Any]]): ToExprFactory[T] = new ToExprFactory[T]: private lazy val elems = elemInstances From a01e97cf6d887f3166b8ed18a041166952409dd1 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 17:06:07 +0200 Subject: [PATCH 08/17] Fix ToExprFactory.derivedSum crash on case-object sum cases TypeRepr.typeConstructorOf(x.getClass) produced a malformed type for singleton (case object) cases, crashing the compiler's implicit search when summoning Mirror.ProductOf for it. Get the case's type statically from TypeRepr.of[T].typeSymbol.children instead, matching how FromExprFactory.derivedSum already resolved sum cases. Co-Authored-By: Claude Sonnet 5 --- library/src/scala/quoted/ToExprFactory.scala | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index 3a3940366072..2eae391f6e12 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -43,10 +43,12 @@ object ToExprFactory: private def derivedSum[T: Mirror.SumOf as m](elemInstances: -> List[ToExprFactory[Any]]): ToExprFactory[T] = new ToExprFactory[T]: private lazy val elems = elemInstances def apply()(using Type[T]): ToExpr[T] = new ToExpr[T]: - def apply(x: T)(using Quotes): Expr[T] = + def apply(x: T)(using quotes: Quotes): Expr[T] = import quotes.reflect.* - TypeRepr.typeConstructorOf(x.getClass).asType match - case '[c] => elems(m.ordinal(x)).asInstanceOf[ToExprFactory[c]].apply().apply(x.asInstanceOf[c]).asInstanceOf[Expr[T]] + val idx = m.ordinal(x) + val caseSym = TypeRepr.of[T].typeSymbol.children(idx) + caseSym.typeRef.asType match + case '[c] => elems(idx).asInstanceOf[ToExprFactory[c]].apply().apply(x.asInstanceOf[c]).asInstanceOf[Expr[T]] /** Bridges any type that already has a plain `ToExpr` (e.g. `Int`, `String`) into `ToExprFactory`. */ given [T] => (te: ToExpr[T]) => ToExprFactory[T]: From 04d8feae446941ad14bbcd00fc0f36e538683f65 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 17:45:51 +0200 Subject: [PATCH 09/17] Remove ToExpr.derived and FromExpr.derived in favor of ToExprFactory/FromExprFactory ToExprFactory/FromExprFactory cover everything ToExpr.derived/FromExpr.derived did (generic and concrete types) plus generic type parameters and fields whose ToExpr/FromExpr instance needs Type[_] without requiring Quotes at the call site, so the two parallel mechanisms are no longer needed. The inline-based derivedProduct/derivedSum bodies are now self-contained again (no shared InternalUtils helpers), since sharing them via a generic method call broke case-object sum dispatch. Also restores the LowPriorityToExpr/LowPriorityFromExpr split for the ToExprFactory/FromExprFactory bridge given, otherwise it's ambiguous with ValueOfToExpr for singleton types. Co-Authored-By: Claude Sonnet 5 --- library/src/scala/quoted/FromExpr.scala | 28 +--------- .../src/scala/quoted/FromExprFactory.scala | 45 +++++++++++++-- library/src/scala/quoted/InternalUtils.scala | 55 ------------------- library/src/scala/quoted/ToExpr.scala | 29 +--------- library/src/scala/quoted/ToExprFactory.scala | 15 ++--- 5 files changed, 53 insertions(+), 119 deletions(-) delete mode 100644 library/src/scala/quoted/InternalUtils.scala diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index 96b427139140..b7b131e0662c 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -30,34 +30,12 @@ trait FromExpr[T] { } +private[quoted] trait LowPriorityFromExpr: + given fromFactory: [T: Type] => (f: FromExprFactory[T]) => FromExpr[T] = f.apply() + /** Default given instances of `FromExpr`. */ object FromExpr extends LowPriorityFromExpr: - import scala.deriving.Mirror - - inline def derived[T: Mirror.Of as m]: FromExpr[T] = inline m match - case given Mirror.ProductOf[T] => - derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, FromExpr]].toList.asInstanceOf[List[FromExpr[Any]]]) - case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) - - private inline def summonAllOrDerive[Elems <: Tuple]: List[FromExpr[Any]] = inline compiletime.erasedValue[Elems] match - case _: EmptyTuple => Nil - case _: (h *: t) => summonOrDerive[h].asInstanceOf[FromExpr[Any]] :: summonAllOrDerive[t] - - private inline def summonOrDerive[T]: FromExpr[T] = compiletime.summonFrom: - case fe: FromExpr[T] => fe - case given Mirror.Of[T] => derived[T] - - @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] - private inline def derivedProduct[T: Mirror.ProductOf as m](elemInstances: => List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: - private lazy val elems = elemInstances - def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = unapplyProduct[T](elems)(x) - - private def derivedSum[T: Mirror.SumOf](elemInstances: -> List[FromExpr[Any]]): FromExpr[T] = new FromExpr[T]: - private lazy val elems = elemInstances - def unapply(x: Expr[T])(using Quotes): Option[T] = unapplySum[T](elems)(x) - /** Default implementation of `FromExpr[Boolean]` * - Transform `'{true}` into `Some(true)` * - Transform `'{false}` into `Some(false)` diff --git a/library/src/scala/quoted/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala index 9e93d27dac68..185b478a17e0 100644 --- a/library/src/scala/quoted/FromExprFactory.scala +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -1,6 +1,7 @@ package scala.quoted import language.experimental.captureChecking +import scala.annotation.tailrec import scala.deriving.Mirror /** A factory that, given a `Type[T]`, produces a `FromExpr[T]`. @@ -33,13 +34,48 @@ object FromExprFactory: def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = import quotes.reflect.* val tpe = TypeRepr.of[T] - val fieldSyms = tpe.typeSymbol.caseFields + val sym = tpe.typeSymbol + val fieldSyms = sym.caseFields val resolvedElems = elems.zip(fieldSyms).map: case (factory, fieldSym) => tpe.memberType(fieldSym).asType match case '[t] => factory.asInstanceOf[FromExprFactory[t]].apply().asInstanceOf[FromExpr[Any]] - unapplyProduct[T](resolvedElems)(x) + @tailrec def stripWrappers(t: Term): Term = t match + case Inlined(_, Nil, e) => stripWrappers(e) + case Block(Nil, e) => stripWrappers(e) + case Typed(e, _) => stripWrappers(e) + case _ => t + + // `new T(args*)` (primary ctor) or `T(args*)` (companion `apply`). + def isOwnConstructor(fun: Term): Boolean = + fun.symbol == sym.primaryConstructor + || (fun.symbol.name == "apply" && fun.symbol.owner == sym.companionModule.moduleClass) + + // defn.TupleClass does not work :/ + def tupleModuleClass = + Symbol.requiredModule(if resolvedElems.isEmpty then "scala.Tuple" else s"scala.Tuple${elems.size}").moduleClass + + def extractArgs(args: List[Term]) = resolvedElems.zip(args).foldRight(Option(List.empty[Any])): + case (_, None) => None + case ((fe, arg), Some(acc)) => fe.unapply(arg.asExprOf[Any]).map(_ :: acc) + + val args = stripWrappers(x.asTerm) match + case Apply(fun, args) if args.length == resolvedElems.size && isOwnConstructor(fun) => + extractArgs(args) + // case '{ type tuple <: Tuple; { $mirror : Mirror.ProductOf[T] }.fromProduct($tuple : tuple ) } => on x does not work :/ + case Apply(Select(recv, "fromProduct"), List(tupleArg)) if recv.tpe <:< TypeRepr.of[deriving.Mirror.ProductOf[T]] => + stripWrappers(tupleArg) match + case Apply(fun, args) + if fun.symbol.name == "apply" && fun.symbol.owner == tupleModuleClass && args.length == resolvedElems.size => + extractArgs(args) + case _ => None + // A bare reference to a singleton (case object/enum case), not a call. TermRef for an explicit given/enum case, TypeRef (via companion) for `derives`. + case t if resolvedElems.isEmpty && t.symbol == (if tpe.termSymbol.exists then tpe.termSymbol else sym.companionModule) => + extractArgs(Nil) + case _ => None + + args.map(vs => m.fromProduct(Tuple.fromArray(vs.toArray))) private def derivedSum[T: Mirror.SumOf](elemInstances: -> List[FromExprFactory[Any]]): FromExprFactory[T] = new FromExprFactory[T]: private lazy val elems = elemInstances @@ -51,11 +87,8 @@ object FromExprFactory: case (factory, caseSym) => caseSym.typeRef.asType match case '[c] => factory.asInstanceOf[FromExprFactory[c]].apply().asInstanceOf[FromExpr[Any]] - unapplySum[T](resolvedElems)(x) + resolvedElems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } /** Bridges any type that already has a plain `FromExpr` (e.g. `Int`, `String`) into `FromExprFactory`. */ given [T] => (fe: FromExpr[T]) => FromExprFactory[T]: def apply()(using Type[T]): FromExpr[T] = fe - -private[quoted] trait LowPriorityFromExpr: - given [T: Type] => (f: FromExprFactory[T]) => FromExpr[T] = f.apply() diff --git a/library/src/scala/quoted/InternalUtils.scala b/library/src/scala/quoted/InternalUtils.scala deleted file mode 100644 index 7da9b4c93f86..000000000000 --- a/library/src/scala/quoted/InternalUtils.scala +++ /dev/null @@ -1,55 +0,0 @@ -package scala.quoted - -import scala.annotation.tailrec -import scala.deriving.Mirror -import scala.quoted.{Expr, Quotes, Type} - -private[quoted] def unapplyProduct[T: {Type, Mirror.ProductOf as m}](using quotes: Quotes)(elems: List[FromExpr[Any]])(x: Expr[T]): Option[T] = - import quotes.reflect.* - val tpe = TypeRepr.of[T] - val sym = tpe.typeSymbol - - @tailrec def stripWrappers(t: Term): Term = t match - case Inlined(_, Nil, e) => stripWrappers(e) - case Block(Nil, e) => stripWrappers(e) - case Typed(e, _) => stripWrappers(e) - case _ => t - - // `new T(args*)` (primary ctor) or `T(args*)` (companion `apply`). - def isOwnConstructor(fun: Term): Boolean = - fun.symbol == sym.primaryConstructor - || (fun.symbol.name == "apply" && fun.symbol.owner == sym.companionModule.moduleClass) - - // defn.TupleClass does not work :/ - def tupleModuleClass = - Symbol.requiredModule(if elems.isEmpty then "scala.Tuple" else s"scala.Tuple${elems.size}").moduleClass - - def extractArgs(args: List[Term]) = elems.zip(args).foldRight(Option(List.empty[Any])): - case (_, None) => None - case ((fe, arg), Some(acc)) => fe.unapply(arg.asExprOf[Any]).map(_ :: acc) - - val args = stripWrappers(x.asTerm) match - case Apply(fun, args) if args.length == elems.size && isOwnConstructor(fun) => - extractArgs(args) - // case '{ type tuple <: Tuple; { $mirror : Mirror.ProductOf[T] }.fromProduct($tuple : tuple ) } => on x does not work :/ - case Apply(Select(recv, "fromProduct"), List(tupleArg)) if recv.tpe <:< TypeRepr.of[deriving.Mirror.ProductOf[T]] => - stripWrappers(tupleArg) match - case Apply(fun, args) - if fun.symbol.name == "apply" && fun.symbol.owner == tupleModuleClass && args.length == elems.size => - extractArgs(args) - case _ => None - // A bare reference to a singleton (case object/enum case), not a call. TermRef for an explicit given/enum case, TypeRef (via companion) for `derives`. - case t if elems.isEmpty && t.symbol == (if tpe.termSymbol.exists then tpe.termSymbol else sym.companionModule) => - extractArgs(Nil) - case _ => None - - args.map(vs => m.fromProduct(Tuple.fromArray(vs.toArray))) - -private[quoted] def unapplySum[T](elems: List[FromExpr[Any]])(x: Expr[T])(using Quotes): Option[T] = - elems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } -private[quoted] def applyProduct[T: Type](elems: List[ToExpr[Any]])(x: T)(using Quotes): Expr[T] = - val mirrorExpr = Expr.summon[Mirror.ProductOf[T]].get - val elemVals = x.asInstanceOf[Product].productIterator.toList - val elemExprs = elems.zip(elemVals).map(_.apply(_)) - val tupleExpr = Expr.ofTupleFromSeq(elemExprs) - '{ $mirrorExpr.fromProduct($tupleExpr) } \ No newline at end of file diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index e412f9db70ba..48ce7e9131be 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -20,35 +20,12 @@ trait ToExpr[T] { } +private[quoted] trait LowPriorityToExpr: + given fromFactory: [T: Type] => (f: ToExprFactory[T]) => ToExpr[T] = f.apply() + /** Default given instances of `ToExpr`. */ object ToExpr extends LowPriorityToExpr { - import scala.deriving.Mirror - - inline def derived[T: Mirror.Of as m]: ToExpr[T] = inline m match - case given Mirror.ProductOf[T] => - derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExpr]].toList.asInstanceOf[List[ToExpr[Any]]]) - case given Mirror.SumOf[T] => - derivedSum[T](summonAllOrDerive[m.MirroredElemTypes]) - - private inline def summonAllOrDerive[Elems <: Tuple]: List[ToExpr[Any]] = inline compiletime.erasedValue[Elems] match - case _: EmptyTuple => Nil - case _: (h *: t) => summonOrDerive[h].asInstanceOf[ToExpr[Any]] :: summonAllOrDerive[t] - - private inline def summonOrDerive[T]: ToExpr[T] = compiletime.summonFrom: - case te: ToExpr[T] => te - case given Mirror.Of[T] => derived[T] - - @nowarn("msg=duplicated at each inline site") // T required for Type.of[T] - private inline def derivedProduct[T: Mirror.ProductOf](elemInstances: -> List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: - private lazy val elems = elemInstances - - def apply(x: T)(using Quotes): Expr[T] = applyProduct(elems)(x) - - private def derivedSum[T: Mirror.SumOf as m](elemInstances: -> List[ToExpr[Any]]): ToExpr[T] = new ToExpr[T]: - private lazy val elems = elemInstances - def apply(x: T)(using Quotes): Expr[T] = elems(m.ordinal(x)).apply(x).asInstanceOf[Expr[T]] - // IMPORTANT Keep in sync with tests/run-staging/liftables.scala given ValueOfToExpr: [T: {ValueOf, Type}] => ToExpr[T]: diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index 2eae391f6e12..e10318b52477 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -5,9 +5,9 @@ import scala.deriving.Mirror /** A factory that, given a `Type[T]`, produces a `ToExpr[T]`. * - * Unlike `ToExpr.derived`, `ToExprFactory.derived` also routes each field/case through - * `ToExprFactory` recursively, so `derives ToExprFactory` on a generic type does not - * require a manual `given [A: {Type, ToExpr}] => ToExpr[Box[A]]` for its type parameters. + * `ToExprFactory.derived` routes each field/case through `ToExprFactory` recursively, so + * `derives ToExprFactory` on a generic type does not require a manual + * `given [A: {Type, ToExpr}] => ToExpr[Box[A]]` for its type parameters. */ trait ToExprFactory[T]: def apply()(using Type[T]): ToExpr[T] @@ -38,7 +38,11 @@ object ToExprFactory: case (factory, fieldSym) => tpe.memberType(fieldSym).asType match case '[t] => factory.asInstanceOf[ToExprFactory[t]].apply().asInstanceOf[ToExpr[Any]] - applyProduct[T](resolvedElems)(x) + val mirrorExpr = Expr.summon[Mirror.ProductOf[T]].get + val elemVals = x.asInstanceOf[Product].productIterator.toList + val elemExprs = resolvedElems.zip(elemVals).map(_.apply(_)) + val tupleExpr = Expr.ofTupleFromSeq(elemExprs) + '{ $mirrorExpr.fromProduct($tupleExpr) } private def derivedSum[T: Mirror.SumOf as m](elemInstances: -> List[ToExprFactory[Any]]): ToExprFactory[T] = new ToExprFactory[T]: private lazy val elems = elemInstances @@ -53,6 +57,3 @@ object ToExprFactory: /** Bridges any type that already has a plain `ToExpr` (e.g. `Int`, `String`) into `ToExprFactory`. */ given [T] => (te: ToExpr[T]) => ToExprFactory[T]: def apply()(using Type[T]): ToExpr[T] = te - -private[quoted] trait LowPriorityToExpr: - given [T: Type] => (f: ToExprFactory[T]) => ToExpr[T] = f.apply() From c18b9020f87551a67ad0d2f32a461bc16d136b49 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Tue, 14 Jul 2026 18:09:10 +0200 Subject: [PATCH 10/17] Fix enum-case dispatch and singleton priority in ToExprFactory/FromExprFactory; migrate tests off ToExpr.derived/FromExpr.derived - derivedSum used typeSymbol.children(idx).typeRef unconditionally, which is wrong for parameterless enum cases (`case Red, Green`): those children are terms, not types, so summoning Mirror.ProductOf for them crashed. Use termRef for term symbols in both ToExprFactory and FromExprFactory. - ValueOfToExpr was ambiguity-fixed to sit above the ToExprFactory/FromExprFactory bridge, but that made it always win for singletons with a Mirror (e.g. a bare `case object`), producing a `valueOf[T]` expression that FromExprFactory's matcher can't parse. Added a third, lower priority tier so a derived Factory instance wins when one exists, falling back to valueOf only for singletons without a Mirror (e.g. `object Marker`). - Migrated both mirror-derivation test suites from `derives ToExpr`/`FromExpr` (removed in a previous commit) to `derives ToExprFactory`/`FromExprFactory`, and from direct `ToExpr.derived`/`FromExpr.derived` calls to `XxxFactory.derived[T].apply()` (with an explicit type argument, since inference doesn't flow backward through `.apply()`, and `(using Quotes)` on top-level givens since Type[_] synthesis always needs Quotes). Co-Authored-By: Claude Sonnet 5 --- .../src/scala/quoted/FromExprFactory.scala | 4 +- library/src/scala/quoted/ToExpr.scala | 11 ++-- library/src/scala/quoted/ToExprFactory.scala | 4 +- .../Macro_1.scala | 52 +++++++++---------- .../Macro_1.scala | 28 +++++----- 5 files changed, 50 insertions(+), 49 deletions(-) diff --git a/library/src/scala/quoted/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala index 185b478a17e0..04a589dfaa8a 100644 --- a/library/src/scala/quoted/FromExprFactory.scala +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -85,7 +85,9 @@ object FromExprFactory: val caseSyms = TypeRepr.of[T].typeSymbol.children val resolvedElems: List[FromExpr[Any]] = elems.zip(caseSyms).map: case (factory, caseSym) => - caseSym.typeRef.asType match + // Parameterless enum cases (`case Red, Green`) are terms, not types; use termRef for those. + val ref = if caseSym.isTerm then caseSym.termRef else caseSym.typeRef + ref.asType match case '[c] => factory.asInstanceOf[FromExprFactory[c]].apply().asInstanceOf[FromExpr[Any]] resolvedElems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 48ce7e9131be..8cd813ce6084 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -20,7 +20,13 @@ trait ToExpr[T] { } -private[quoted] trait LowPriorityToExpr: +// Lowest priority: only used when nothing more specific (including a derived +// ToExprFactory instance) is found, e.g. a non-case singleton like `object Marker`. +private[quoted] trait LowestPriorityToExpr: + given ValueOfToExpr: [T: {ValueOf, Type}] => ToExpr[T]: + def apply(x: T)(using Quotes): Expr[T] = '{ valueOf[T] } + +private[quoted] trait LowPriorityToExpr extends LowestPriorityToExpr: given fromFactory: [T: Type] => (f: ToExprFactory[T]) => ToExpr[T] = f.apply() /** Default given instances of `ToExpr`. */ @@ -28,9 +34,6 @@ object ToExpr extends LowPriorityToExpr { // IMPORTANT Keep in sync with tests/run-staging/liftables.scala - given ValueOfToExpr: [T: {ValueOf, Type}] => ToExpr[T]: - def apply(x: T)(using Quotes): Expr[T] = '{ valueOf[T] } - /** Default implementation of `ToExpr[Boolean]`. */ given BooleanToExpr[T <: Boolean]: ToExpr[T] with { def apply(x: T)(using Quotes) = diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index e10318b52477..9726c0097428 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -51,7 +51,9 @@ object ToExprFactory: import quotes.reflect.* val idx = m.ordinal(x) val caseSym = TypeRepr.of[T].typeSymbol.children(idx) - caseSym.typeRef.asType match + // Parameterless enum cases (`case Red, Green`) are terms, not types; use termRef for those. + val ref = if caseSym.isTerm then caseSym.termRef else caseSym.typeRef + ref.asType match case '[c] => elems(idx).asInstanceOf[ToExprFactory[c]].apply().apply(x.asInstanceOf[c]).asInstanceOf[Expr[T]] /** Bridges any type that already has a plain `ToExpr` (e.g. `Int`, `String`) into `ToExprFactory`. */ diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala index 96c72ea206f3..af9176320398 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -1,65 +1,61 @@ import scala.quoted.* // Plain product, primitives -case class Point(x: Int, y: Int) derives ToExpr, FromExpr +case class Point(x: Int, y: Int) derives ToExprFactory, FromExprFactory // Product, mixed field kinds -case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExpr, FromExpr +case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExprFactory, FromExprFactory // Same shape, different types (wrong-mirror guard) -case class Meters(value: Int) derives ToExpr, FromExpr -case class Seconds(value: Int) derives ToExpr, FromExpr +case class Meters(value: Int) derives ToExprFactory, FromExprFactory +case class Seconds(value: Int) derives ToExprFactory, FromExprFactory // `derived` on a tuple type directly -given tuple2FromExpr: FromExpr[(Int, String)] = FromExpr.derived -given tuple2ToExpr: ToExpr[(Int, String)] = ToExpr.derived -given tuple5FromExpr: FromExpr[(Int, String, Boolean, Double, Char)] = FromExpr.derived -given tuple5ToExpr: ToExpr[(Int, String, Boolean, Double, Char)] = ToExpr.derived +given tuple2FromExpr(using Quotes): FromExpr[(Int, String)] = FromExprFactory.derived[(Int, String)].apply() +given tuple2ToExpr(using Quotes): ToExpr[(Int, String)] = ToExprFactory.derived[(Int, String)].apply() +given tuple5FromExpr(using Quotes): FromExpr[(Int, String, Boolean, Double, Char)] = FromExprFactory.derived[(Int, String, Boolean, Double, Char)].apply() +given tuple5ToExpr(using Quotes): ToExpr[(Int, String, Boolean, Double, Char)] = ToExprFactory.derived[(Int, String, Boolean, Double, Char)].apply() // Nested products, cross-object -case class Address(city: String, zip: Int) derives FromExpr +case class Address(city: String, zip: Int) derives FromExprFactory object Namespace: - case class Person(name: String, address: Address) derives FromExpr + case class Person(name: String, address: Address) derives FromExprFactory // Three levels of nesting -case class Company(hq: Address, ceo: Namespace.Person) derives FromExpr +case class Company(hq: Address, ceo: Namespace.Person) derives FromExprFactory // Singleton (case object) -case object Singleton derives ToExpr, FromExpr +case object Singleton derives ToExprFactory, FromExprFactory // Generic product (needs an explicit Type/instance bound) -case class Box[A](value: A) -given [A: {Type, ToExpr}] => ToExpr[Box[A]] = ToExpr.derived -given [A: {Type, FromExpr}] => FromExpr[Box[A]] = FromExpr.derived +case class Box[A](value: A) derives FromExprFactory, ToExprFactory // Sum: sealed trait + cases, auto-derived -sealed trait Shape derives ToExpr, FromExpr +sealed trait Shape derives ToExprFactory, FromExprFactory object Shape: case class Circle(r: Double) extends Shape case class Rect(w: Double, h: Double) extends Shape case object Origin extends Shape // Sum: enum, singleton + parameterized cases -enum Color derives ToExpr, FromExpr: +enum Color derives ToExprFactory, FromExprFactory: case Red, Green case Custom(hex: String) // Product with a sum-typed field -case class Container(name: String, shape: Shape) derives ToExpr, FromExpr +case class Container(name: String, shape: Shape) derives ToExprFactory, FromExprFactory // Zero-arg product (not a singleton) -case class Blank() derives ToExpr, FromExpr +case class Blank() derives ToExprFactory, FromExprFactory // Generic sum (explicit bound on the trait; cases auto-derived) -sealed trait Result[+A] +sealed trait Result[+A] derives FromExprFactory, ToExprFactory object Result: case class Ok[A](value: A) extends Result[A] case object Fail extends Result[Nothing] -given [A: {Type, FromExpr}] => FromExpr[Result[A]] = FromExpr.derived -given [A: {Type, ToExpr}] => ToExpr[Result[A]] = ToExpr.derived // Nested sum hierarchy, two levels of dispatch -sealed trait Vehicle derives ToExpr, FromExpr +sealed trait Vehicle derives ToExprFactory, FromExprFactory object Vehicle: sealed trait Motorized extends Vehicle object Motorized: @@ -68,7 +64,7 @@ object Vehicle: case class Bicycle(gears: Int) extends Vehicle // Recursive sum: a case's own field is the enclosing type -enum Arith derives ToExpr, FromExpr: +enum Arith derives ToExprFactory, FromExprFactory: case Lit(n: Int) case Add(l: Arith, r: Arith) case Neg(e: Arith) @@ -78,7 +74,7 @@ case class Big25( f1: Int, f2: Int, f3: Int, f4: Int, f5: Int, f6: Int, f7: Int, f8: Int, f9: Int, f10: Int, f11: Int, f12: Int, f13: Int, f14: Int, f15: Int, f16: Int, f17: Int, f18: Int, f19: Int, f20: Int, f21: Int, f22: Int, f23: Int, f24: Int, f25: Int -) derives ToExpr, FromExpr +) derives ToExprFactory, FromExprFactory object Macro: // Constructor-call recognition: `apply` and `new` @@ -134,7 +130,7 @@ object Macro: inline def matchTuple2: Boolean = ${ Macro.matchTuple2Impl } inline def roundTripTuple5: Boolean = ${ Macro.roundTripTuple5Impl } - // ToExpr.derived -> FromExpr.derived round trip, all cases above + // ToExpr -> FromExpr round trip, all cases above inline def roundTrips: Boolean = ${ Macro.roundTripsImpl } private def check[T: Type: FromExpr](expr: Expr[T], expected: T)(using Quotes): Expr[Boolean] = @@ -182,7 +178,7 @@ object Macro: check[Vehicle]('{ Vehicle.Bicycle(21) }, Vehicle.Bicycle(21)) def wrongNestedVariantIsNoneImpl(using Quotes): Expr[Boolean] = - given FromExpr[Vehicle.Motorized.Motorcycle] = FromExpr.derived + given FromExpr[Vehicle.Motorized.Motorcycle] = FromExprFactory.derived[Vehicle.Motorized.Motorcycle].apply() val e: Expr[Vehicle.Motorized.Car] = '{ Vehicle.Motorized.Car(4) } checkNone(e.asInstanceOf[Expr[Vehicle.Motorized.Motorcycle]]) @@ -203,7 +199,7 @@ object Macro: checkNone(e.asInstanceOf[Expr[Address]]) def wrongSumVariantIsNoneImpl(using Quotes): Expr[Boolean] = - given FromExpr[Shape.Rect] = FromExpr.derived + given FromExpr[Shape.Rect] = FromExprFactory.derived[Shape.Rect].apply() val e: Expr[Shape.Circle] = '{ Shape.Circle(1.0) } checkNone(e.asInstanceOf[Expr[Shape.Rect]]) diff --git a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala index f744194b4f9a..afe61a19fb26 100644 --- a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala @@ -1,51 +1,49 @@ import scala.quoted.* // Plain product, primitives -case class Point(x: Int, y: Int) derives ToExpr +case class Point(x: Int, y: Int) derives ToExprFactory // Nested products, cross-object -case class Address(city: String, zip: Int) derives ToExpr +case class Address(city: String, zip: Int) derives ToExprFactory object Namespace: - case class Person(name: String, address: Address) derives ToExpr + case class Person(name: String, address: Address) derives ToExprFactory // Singleton (case object) -case object Singleton derives ToExpr +case object Singleton derives ToExprFactory // Generic product (needs an explicit Type/instance bound) -case class Box[A](value: A) -given [A: {Type, ToExpr}] => ToExpr[Box[A]] = ToExpr.derived +case class Box[A](value: A) derives ToExprFactory // Product, mixed field kinds -case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExpr +case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExprFactory // Field type (List[Int]) whose ToExpr needs Quotes ambient, not just Type/instance case class Tagged(tags: List[Int]) -given taggedToExpr(using Quotes): ToExpr[Tagged] = ToExpr.derived +given taggedToExpr(using Quotes): ToExpr[Tagged] = ToExprFactory.derived[Tagged].apply() // Sum: sealed trait + cases, auto-derived -sealed trait Shape derives ToExpr +sealed trait Shape derives ToExprFactory object Shape: case class Circle(r: Double) extends Shape case class Rect(w: Double, h: Double) extends Shape case object Origin extends Shape // Sum: enum, singleton + parameterized cases -enum Color derives ToExpr: +enum Color derives ToExprFactory: case Red, Green case Custom(hex: String) // Product with a sum-typed field -case class Container(name: String, shape: Shape) derives ToExpr +case class Container(name: String, shape: Shape) derives ToExprFactory // Zero-arg product (not a singleton) -case class Blank() derives ToExpr +case class Blank() derives ToExprFactory // Generic sum (explicit bound on the trait; cases auto-derived) -sealed trait Result[+A] +sealed trait Result[+A] derives ToExprFactory object Result: case class Ok[A](value: A) extends Result[A] case object Fail extends Result[Nothing] -given [A: {Type, ToExpr}] => ToExpr[Result[A]] = ToExpr.derived // Non-case singleton, lifted via valueOf[T] (no `derives`) object Marker @@ -85,7 +83,7 @@ object Macro: def liftTaggedImpl(using Quotes): Expr[Tagged] = Expr(Tagged(List(1, 2, 3))) def liftCircleImpl(using Quotes): Expr[Shape.Circle] = // `Circle` has no standalone top-level `ToExpr` (auto-derived via `Shape`), so derive locally - given ToExpr[Shape.Circle] = ToExpr.derived + given ToExpr[Shape.Circle] = ToExprFactory.derived[Shape.Circle].apply() Expr(Shape.Circle(1.0)) def liftShapeCircleImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Circle(2.0)) def liftShapeRectImpl(using Quotes): Expr[Shape] = Expr[Shape](Shape.Rect(1.0, 2.0)) From 8264cd418a5c1b4df9dc1dd90127affaf3c433e0 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Wed, 15 Jul 2026 16:44:59 +0200 Subject: [PATCH 11/17] Add deferred-Type container/tuple instances to ToExprFactory/FromExprFactory Array, Seq, List, Set, Map, Option, Some, Either, Left, Right and all Tuple1..22/TupleCons instances now have dedicated ToExprFactory/FromExprFactory givens that defer Type[T] acquisition until apply()/unapply() is called, so they compose with `derives ToExprFactory`/`derives FromExprFactory` on types with container- or tuple-typed fields (previously such fields required a Type/Quotes ambient context unavailable at derivation time). The old hand-written ToExpr/FromExpr container givens now proxy to these factories instead of duplicating logic. Co-Authored-By: Claude Sonnet 5 --- library/src/scala/quoted/FromExpr.scala | 89 +- .../src/scala/quoted/FromExprFactory.scala | 870 +++++++++++++++++- library/src/scala/quoted/ToExpr.scala | 91 +- library/src/scala/quoted/ToExprFactory.scala | 759 ++++++++++++++- .../Macro_1.scala | 76 +- .../Test_2.scala | 2 + .../Macro_1.scala | 29 +- .../Test_2.scala | 7 + 8 files changed, 1781 insertions(+), 142 deletions(-) diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index b7b131e0662c..a6f2cbdd6949 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -115,14 +115,8 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{None}` into `Some(None)` * - Otherwise returns `None` */ - given OptionFromExpr[T](using Type[T], FromExpr[T]): FromExpr[Option[T]] with { - def unapply(x: Expr[Option[T]])(using Quotes) = x match { - case '{ Option[T](${Expr(y)}: T) } => Some(Option(y)) - case '{ None } => Some(None) - case '{ ${Expr(opt)} : Some[T] } => Some(opt) - case _ => None - } - } + given OptionFromExpr: [T: {Type, FromExpr}] => FromExpr[Option[T]]: + def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] = summon[FromExprFactory[Option[T]]].apply().unapply(x) /** Default implementation of `FromExpr[None]` * - Transform `'{None}` into `Some(None)` @@ -139,13 +133,8 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{Some(x)}` into `Some(Some(x))` if `x` can be transformed using `FromExpr[T]` * - Otherwise returns `None` */ - given SomeFromExpr[T](using Type[T], FromExpr[T]): FromExpr[Some[T]] with { - def unapply(x: Expr[Some[T]])(using Quotes) = x match { - case '{ new Some[T](${Expr(y)}) } => Some(Some(y)) - case '{ Some[T](${Expr(y)}) } => Some(Some(y)) - case _ => None - } - } + given SomeFromExpr: [T: {Type, FromExpr}] => FromExpr[Some[T]]: + def unapply(x: Expr[Some[T]])(using Quotes): Option[Some[T]] = summon[FromExprFactory[Some[T]]].apply().unapply(x) /** Default implementation of `FromExpr[StringContext]` * - Transform `'{StringContext(args*)}` into `Some(StringContext(args*))` if `args` is explicit and each one is liftable @@ -440,15 +429,8 @@ object FromExpr extends LowPriorityFromExpr: * - Transform sequences that come out of varargs * - Otherwise returns `None` */ - given SeqFromExpr[T](using Type[T], FromExpr[T]): FromExpr[Seq[T]] with { - def unapply(x: Expr[Seq[T]])(using Quotes) = x match { - case Varargs(Exprs(elems)) => Some(elems) - case '{ scala.Seq[T](${Varargs(Exprs(elems))}*) } => Some(elems) - case '{ scala.collection.immutable.Seq[T](${Varargs(Exprs(elems))}*) } => Some(elems) - case '{ ${Expr(x)}: List[T] } => Some(x) - case _ => None - } - } + given SeqFromExpr: [T: {Type, FromExpr}] => FromExpr[Seq[T]]: + def unapply(x: Expr[Seq[T]])(using Quotes): Option[Seq[T]] = summon[FromExprFactory[Seq[T]]].apply().unapply(x) /** Default implementation of `FromExpr[Nil]` * - Transform `'{Nil}` into `Some(Nil)` @@ -467,78 +449,43 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{Nil}` into `Some(Nil)` * - Otherwise returns `None` */ - given ListFromExpr[T](using Type[T], FromExpr[T]): FromExpr[List[T]] with { - def unapply(x: Expr[List[T]])(using Quotes) = x match { - case '{ scala.List[T](${Varargs(Exprs(elems))}*) } => Some(elems.toList) - case '{ scala.List.empty[T] } => Some(Nil) - case '{ Nil } => Some(Nil) - case '{ scala.collection.immutable.List[T](${Varargs(Exprs(elems))}*) } => Some(elems.toList) - case '{ scala.collection.immutable.List.empty[T] } => Some(Nil) - case _ => None - } - } + given ListFromExpr: [T: {Type, FromExpr}] => FromExpr[List[T]]: + def unapply(x: Expr[List[T]])(using Quotes): Option[List[T]] = summon[FromExprFactory[List[T]]].apply().unapply(x) /** Default implementation of `FromExpr[Set]` * - Transform `'{Set(x1, ..., xn)}` into `Some(Set(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform `'{Set.empty}` into `Some(Set())` * - Otherwise returns `None` */ - given SetFromExpr[T](using Type[T], FromExpr[T]): FromExpr[Set[T]] with { - def unapply(x: Expr[Set[T]])(using Quotes) = x match { - case '{ Set[T](${Varargs(Exprs(elems))}*) } => Some(elems.toSet) - case '{ Set.empty[T] } => Some(Set.empty[T]) - case '{ scala.collection.immutable.Set[T](${Varargs(Exprs(elems))}*) } => Some(elems.toSet) - case '{ scala.collection.immutable.Set.empty[T] } => Some(Set.empty[T]) - case _ => None - } - } + given SetFromExpr: [T: {Type, FromExpr}] => FromExpr[Set[T]]: + def unapply(x: Expr[Set[T]])(using Quotes): Option[Set[T]] = summon[FromExprFactory[Set[T]]].apply().unapply(x) /** Default implementation of `FromExpr[Map]` * - Transform `'{Map(x1, ..., xn)}` into `Some(Map(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform `'{Map.empty}` into `Some(Map())` * - Otherwise returns `None` */ - given MapFromExpr[T, U](using Type[T], Type[U], FromExpr[T], FromExpr[U]): FromExpr[Map[T, U]] with { - def unapply(x: Expr[Map[T, U]])(using Quotes) = x match { - case '{ Map[T, U](${Varargs(Exprs(elems))}*) } => Some(elems.toMap) - case '{ Map.empty[T, U] } => Some(Map.empty) - case '{ scala.collection.immutable.Map[T, U](${Varargs(Exprs(elems))}*) } => Some(elems.toMap) - case '{ scala.collection.immutable.Map.empty[T, U] } => Some(Map.empty) - case _ => None - } - } + given MapFromExpr: [T: {Type, FromExpr}, U: {Type, FromExpr}] => FromExpr[Map[T, U]]: + def unapply(x: Expr[Map[T, U]])(using Quotes): Option[Map[T, U]] = summon[FromExprFactory[Map[T, U]]].apply().unapply(x) /** Default implementation of `FromExpr[Either]` * - Transform `'{Left(x)}` into `Some(Left(x))` if `x` can be transformed using `FromExpr[L]` * - Transform `'{Right(x)}` into `Some(Right(x))` if `x` can be transformed using `FromExpr[R]` * - Otherwise returns `None` */ - given EitherFromExpr[L, R](using Type[L], Type[R], FromExpr[L], FromExpr[R]): FromExpr[Either[L, R]] with { - def unapply(x: Expr[Either[L, R]])(using Quotes) = x match { - case '{ $x: Left[L, R] } => x.value - case '{ $x: Right[L, R] } => x.value - case _ => None - } - } + given EitherFromExpr: [L: {Type, FromExpr}, R: {Type, FromExpr}] => FromExpr[Either[L, R]]: + def unapply(x: Expr[Either[L, R]])(using Quotes): Option[Either[L, R]] = summon[FromExprFactory[Either[L, R]]].apply().unapply(x) /** Default implementation of `FromExpr[Left]` * - Transform `'{Left(x)}` into `Some(Left(x))` if `x` can be transformed using `FromExpr[L]` * - Otherwise returns `None` */ - given LeftFromExpr[L, R](using Type[L], Type[R], FromExpr[L]): FromExpr[Left[L, R]] with { - def unapply(x: Expr[Left[L, R]])(using Quotes) = x match { - case '{ Left[L, R](${Expr(x)}) } => Some(Left(x)) - case _ => None - } - } + given LeftFromExpr: [L: {Type, FromExpr}, R: Type] => FromExpr[Left[L, R]]: + def unapply(x: Expr[Left[L, R]])(using Quotes): Option[Left[L, R]] = summon[FromExprFactory[Left[L, R]]].apply().unapply(x) /** Default implementation of `FromExpr[Right]` * - Transform `'{Right(x)}` into `Some(Right(x))` if `x` can be transformed using `FromExpr[R]` * - Otherwise returns `None` */ - given RightFromExpr[L, R](using Type[L], Type[R], FromExpr[R]): FromExpr[Right[L, R]] with { - def unapply(x: Expr[Right[L, R]])(using Quotes) = x match { - case '{ Right[L, R](${Expr(x)}) } => Some(Right(x)) - case _ => None - } - } + given RightFromExpr: [L: Type, R: {Type, FromExpr}] => FromExpr[Right[L, R]]: + def unapply(x: Expr[Right[L, R]])(using Quotes): Option[Right[L, R]] = summon[FromExprFactory[Right[L, R]]].apply().unapply(x) diff --git a/library/src/scala/quoted/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala index 04a589dfaa8a..a0a0b7ef9ec1 100644 --- a/library/src/scala/quoted/FromExprFactory.scala +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -3,6 +3,7 @@ package scala.quoted import language.experimental.captureChecking import scala.annotation.tailrec import scala.deriving.Mirror +import scala.reflect.ClassTag /** A factory that, given a `Type[T]`, produces a `FromExpr[T]`. * @@ -92,5 +93,872 @@ object FromExprFactory: resolvedElems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } /** Bridges any type that already has a plain `FromExpr` (e.g. `Int`, `String`) into `FromExprFactory`. */ - given [T] => (fe: FromExpr[T]) => FromExprFactory[T]: + given fromFromExpr: [T] => (fe: FromExpr[T]) => FromExprFactory[T]: def apply()(using Type[T]): FromExpr[T] = fe + + // Container instances below defer `Type[T]` for the same reason as the `ToExprFactory` side. + // Each decomposes its own `Type[Xxx[T]]` via a quote type pattern to recover `Type[T]`; the + // cast is safe since the pattern only ever matches with `t =:= T`. + + given arrayFromExprFactory: [T: {FromExprFactory as tf, ClassTag as ct}] => FromExprFactory[Array[T]]: + def apply()(using Type[Array[T]]): FromExpr[Array[T]] = new FromExpr[Array[T]]: + def unapply(x: Expr[Array[T]])(using Quotes): Option[Array[T]] = summon[Type[Array[T]]] match + case '[Array[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given FromExpr[T] = tf.apply() + val result: Option[Array[T]] = x match + case '{ Array[T](${Varargs(Exprs(elems))}*)(using ${_}) } => Some(elems.toArray(using ct)) + case _ => None + result + + given seqFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Seq[T]]: + def apply()(using Type[Seq[T]]): FromExpr[Seq[T]] = new FromExpr[Seq[T]]: + def unapply(x: Expr[Seq[T]])(using Quotes): Option[Seq[T]] = summon[Type[Seq[T]]] match + case '[Seq[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given FromExpr[T] = tf.apply() + val result: Option[Seq[T]] = x match + case Varargs(Exprs(elems)) => Some(elems) + case '{ scala.Seq[T](${Varargs(Exprs(elems))}*) } => Some(elems) + case '{ scala.collection.immutable.Seq[T](${Varargs(Exprs(elems))}*) } => Some(elems) + case '{ ${Expr(xs)}: List[T] } => Some(xs) + case _ => None + result + + given listFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[List[T]]: + def apply()(using Type[List[T]]): FromExpr[List[T]] = new FromExpr[List[T]]: + def unapply(x: Expr[List[T]])(using Quotes): Option[List[T]] = summon[Type[List[T]]] match + case '[List[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given FromExpr[T] = tf.apply() + val result: Option[List[T]] = x match + case '{ scala.List[T](${Varargs(Exprs(elems))}*) } => Some(elems.toList) + case '{ scala.List.empty[T] } => Some(Nil) + case '{ Nil } => Some(Nil) + case '{ scala.collection.immutable.List[T](${Varargs(Exprs(elems))}*) } => Some(elems.toList) + case '{ scala.collection.immutable.List.empty[T] } => Some(Nil) + case _ => None + result + + given setFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Set[T]]: + def apply()(using Type[Set[T]]): FromExpr[Set[T]] = new FromExpr[Set[T]]: + def unapply(x: Expr[Set[T]])(using Quotes): Option[Set[T]] = summon[Type[Set[T]]] match + case '[Set[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given FromExpr[T] = tf.apply() + val result: Option[Set[T]] = x match + case '{ Set[T](${Varargs(Exprs(elems))}*) } => Some(elems.toSet) + case '{ Set.empty[T] } => Some(Set.empty[T]) + case '{ scala.collection.immutable.Set[T](${Varargs(Exprs(elems))}*) } => Some(elems.toSet) + case '{ scala.collection.immutable.Set.empty[T] } => Some(Set.empty[T]) + case _ => None + result + + given mapFromExprFactory: [T: FromExprFactory as tf, U: FromExprFactory as uf] => FromExprFactory[Map[T, U]]: + def apply()(using Type[Map[T, U]]): FromExpr[Map[T, U]] = new FromExpr[Map[T, U]]: + def unapply(x: Expr[Map[T, U]])(using Quotes): Option[Map[T, U]] = summon[Type[Map[T, U]]] match + case '[Map[t, u]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given Type[U] = Type.of[u].asInstanceOf[Type[U]] + given FromExpr[T] = tf.apply() + given FromExpr[U] = uf.apply() + val result: Option[Map[T, U]] = x match + case '{ Map[T, U](${Varargs(Exprs(elems))}*) } => Some(elems.toMap) + case '{ Map.empty[T, U] } => Some(Map.empty) + case '{ scala.collection.immutable.Map[T, U](${Varargs(Exprs(elems))}*) } => Some(elems.toMap) + case '{ scala.collection.immutable.Map.empty[T, U] } => Some(Map.empty) + case _ => None + result + + given optionFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Option[T]]: + def apply()(using Type[Option[T]]): FromExpr[Option[T]] = new FromExpr[Option[T]]: + def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] = summon[Type[Option[T]]] match + case '[Option[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given FromExpr[T] = tf.apply() + val result: Option[Option[T]] = x match + case '{ Option[T](${Expr(y)}: T) } => Some(Option(y)) + case '{ None } => Some(None) + case '{ ${Expr(opt)} : Some[T] } => Some(opt) + case _ => None + result + + given someFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Some[T]]: + def apply()(using Type[Some[T]]): FromExpr[Some[T]] = new FromExpr[Some[T]]: + def unapply(x: Expr[Some[T]])(using Quotes): Option[Some[T]] = summon[Type[Some[T]]] match + case '[Some[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given FromExpr[T] = tf.apply() + val result: Option[Some[T]] = x match + case '{ new Some[T](${Expr(y)}) } => Some(Some(y)) + case '{ Some[T](${Expr(y)}) } => Some(Some(y)) + case _ => None + result + + given eitherFromExprFactory: [L: FromExprFactory as lf, R: FromExprFactory as rf] => FromExprFactory[Either[L, R]]: + def apply()(using Type[Either[L, R]]): FromExpr[Either[L, R]] = new FromExpr[Either[L, R]]: + def unapply(x: Expr[Either[L, R]])(using Quotes): Option[Either[L, R]] = summon[Type[Either[L, R]]] match + case '[Either[l, r]] => + given Type[L] = Type.of[l].asInstanceOf[Type[L]] + given Type[R] = Type.of[r].asInstanceOf[Type[R]] + given FromExpr[L] = lf.apply() + given FromExpr[R] = rf.apply() + val result: Option[Either[L, R]] = x match + case '{ $y: Left[L, R] } => y.value + case '{ $y: Right[L, R] } => y.value + case _ => None + result + + given leftFromExprFactory: [L: FromExprFactory as lf, R] => FromExprFactory[Left[L, R]]: + def apply()(using Type[Left[L, R]]): FromExpr[Left[L, R]] = new FromExpr[Left[L, R]]: + def unapply(x: Expr[Left[L, R]])(using Quotes): Option[Left[L, R]] = summon[Type[Left[L, R]]] match + case '[Left[l, r]] => + given Type[L] = Type.of[l].asInstanceOf[Type[L]] + given Type[R] = Type.of[r].asInstanceOf[Type[R]] + given FromExpr[L] = lf.apply() + val result: Option[Left[L, R]] = x match + case '{ Left[L, R](${Expr(y)}) } => Some(Left(y)) + case _ => None + result + + given rightFromExprFactory: [L, R: FromExprFactory as rf] => FromExprFactory[Right[L, R]]: + def apply()(using Type[Right[L, R]]): FromExpr[Right[L, R]] = new FromExpr[Right[L, R]]: + def unapply(x: Expr[Right[L, R]])(using Quotes): Option[Right[L, R]] = summon[Type[Right[L, R]]] match + case '[Right[l, r]] => + given Type[L] = Type.of[l].asInstanceOf[Type[L]] + given Type[R] = Type.of[r].asInstanceOf[Type[R]] + given FromExpr[R] = rf.apply() + val result: Option[Right[L, R]] = x match + case '{ Right[L, R](${Expr(y)}) } => Some(Right(y)) + case _ => None + result + + // Tuple instances: same deferred-Type pattern as the containers above, mirroring the + // hand-written Tuple1..22 instances in FromExpr (there is no hand-written TupleCons FromExpr). + + given tuple1FromExprFactory: [T1: FromExprFactory as tf1] => FromExprFactory[Tuple1[T1]]: + def apply()(using Type[Tuple1[T1]]): FromExpr[Tuple1[T1]] = new FromExpr[Tuple1[T1]]: + def unapply(x: Expr[Tuple1[T1]])(using Quotes): Option[Tuple1[T1]] = summon[Type[Tuple1[T1]]] match + case '[Tuple1[t1]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given FromExpr[T1] = tf1.apply() + val result: Option[Tuple1[T1]] = x match + case '{ new Tuple1[T1](${Expr(y1)}) } => Some(Tuple1(y1)) + case '{ Tuple1[T1](${Expr(y1)}) } => Some(Tuple1(y1)) + case _ => None + result + + given tuple2FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2] => FromExprFactory[Tuple2[T1, T2]]: + def apply()(using Type[Tuple2[T1, T2]]): FromExpr[Tuple2[T1, T2]] = new FromExpr[Tuple2[T1, T2]]: + def unapply(x: Expr[Tuple2[T1, T2]])(using Quotes): Option[Tuple2[T1, T2]] = summon[Type[Tuple2[T1, T2]]] match + case '[Tuple2[t1, t2]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + val result: Option[Tuple2[T1, T2]] = x match + case '{ new Tuple2[T1, T2](${Expr(y1)}, ${Expr(y2)}) } => Some(Tuple2(y1, y2)) + case '{ Tuple2[T1, T2](${Expr(y1)}, ${Expr(y2)}) } => Some(Tuple2(y1, y2)) + case '{ (${Expr(y1)}: T1) -> (${Expr(y2)}: T2) } => Some(Tuple2(y1, y2)) + case _ => None + result + + given tuple3FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3] => FromExprFactory[Tuple3[T1, T2, T3]]: + def apply()(using Type[Tuple3[T1, T2, T3]]): FromExpr[Tuple3[T1, T2, T3]] = new FromExpr[Tuple3[T1, T2, T3]]: + def unapply(x: Expr[Tuple3[T1, T2, T3]])(using Quotes): Option[Tuple3[T1, T2, T3]] = summon[Type[Tuple3[T1, T2, T3]]] match + case '[Tuple3[t1, t2, t3]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + val result: Option[Tuple3[T1, T2, T3]] = x match + case '{ new Tuple3[T1, T2, T3](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}) } => Some(Tuple3(y1, y2, y3)) + case '{ Tuple3[T1, T2, T3](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}) } => Some(Tuple3(y1, y2, y3)) + case _ => None + result + + given tuple4FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4] => FromExprFactory[Tuple4[T1, T2, T3, T4]]: + def apply()(using Type[Tuple4[T1, T2, T3, T4]]): FromExpr[Tuple4[T1, T2, T3, T4]] = new FromExpr[Tuple4[T1, T2, T3, T4]]: + def unapply(x: Expr[Tuple4[T1, T2, T3, T4]])(using Quotes): Option[Tuple4[T1, T2, T3, T4]] = summon[Type[Tuple4[T1, T2, T3, T4]]] match + case '[Tuple4[t1, t2, t3, t4]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + val result: Option[Tuple4[T1, T2, T3, T4]] = x match + case '{ new Tuple4[T1, T2, T3, T4](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}) } => Some(Tuple4(y1, y2, y3, y4)) + case '{ Tuple4[T1, T2, T3, T4](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}) } => Some(Tuple4(y1, y2, y3, y4)) + case _ => None + result + + given tuple5FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5] => FromExprFactory[Tuple5[T1, T2, T3, T4, T5]]: + def apply()(using Type[Tuple5[T1, T2, T3, T4, T5]]): FromExpr[Tuple5[T1, T2, T3, T4, T5]] = new FromExpr[Tuple5[T1, T2, T3, T4, T5]]: + def unapply(x: Expr[Tuple5[T1, T2, T3, T4, T5]])(using Quotes): Option[Tuple5[T1, T2, T3, T4, T5]] = summon[Type[Tuple5[T1, T2, T3, T4, T5]]] match + case '[Tuple5[t1, t2, t3, t4, t5]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + val result: Option[Tuple5[T1, T2, T3, T4, T5]] = x match + case '{ new Tuple5[T1, T2, T3, T4, T5](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5)) + case '{ Tuple5[T1, T2, T3, T4, T5](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5)) + case _ => None + result + + given tuple6FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6] => FromExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]: + def apply()(using Type[Tuple6[T1, T2, T3, T4, T5, T6]]): FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]] = new FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: + def unapply(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]])(using Quotes): Option[Tuple6[T1, T2, T3, T4, T5, T6]] = summon[Type[Tuple6[T1, T2, T3, T4, T5, T6]]] match + case '[Tuple6[t1, t2, t3, t4, t5, t6]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + val result: Option[Tuple6[T1, T2, T3, T4, T5, T6]] = x match + case '{ new Tuple6[T1, T2, T3, T4, T5, T6](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6)) + case '{ Tuple6[T1, T2, T3, T4, T5, T6](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6)) + case _ => None + result + + given tuple7FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7] => FromExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def apply()(using Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]): FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def unapply(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]])(using Quotes): Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = summon[Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]] match + case '[Tuple7[t1, t2, t3, t4, t5, t6, t7]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + val result: Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = x match + case '{ new Tuple7[T1, T2, T3, T4, T5, T6, T7](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7)) + case '{ Tuple7[T1, T2, T3, T4, T5, T6, T7](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7)) + case _ => None + result + + given tuple8FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8] => FromExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def apply()(using Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]): FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def unapply(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]])(using Quotes): Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = summon[Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]] match + case '[Tuple8[t1, t2, t3, t4, t5, t6, t7, t8]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + val result: Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = x match + case '{ new Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8)) + case '{ Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8)) + case _ => None + result + + given tuple9FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9] => FromExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def apply()(using Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]): FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def unapply(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]])(using Quotes): Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = summon[Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]] match + case '[Tuple9[t1, t2, t3, t4, t5, t6, t7, t8, t9]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + val result: Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = x match + case '{ new Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9)) + case '{ Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9)) + case _ => None + result + + given tuple10FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10] => FromExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def apply()(using Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]): FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def unapply(x: Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])(using Quotes): Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = summon[Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]] match + case '[Tuple10[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + val result: Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = x match + case '{ new Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10)) + case '{ Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10)) + case _ => None + result + + given tuple11FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11] => FromExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def apply()(using Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]): FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def unapply(x: Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]])(using Quotes): Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = summon[Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]] match + case '[Tuple11[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + val result: Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = x match + case '{ new Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11)) + case '{ Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11)) + case _ => None + result + + given tuple12FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12] => FromExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def apply()(using Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]): FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def unapply(x: Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]])(using Quotes): Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = summon[Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]] match + case '[Tuple12[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + val result: Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = x match + case '{ new Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12)) + case '{ Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12)) + case _ => None + result + + given tuple13FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13] => FromExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def apply()(using Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]): FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def unapply(x: Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]])(using Quotes): Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = summon[Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]] match + case '[Tuple13[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + val result: Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = x match + case '{ new Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13)) + case '{ Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13)) + case _ => None + result + + given tuple14FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14] => FromExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def apply()(using Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]): FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def unapply(x: Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]])(using Quotes): Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = summon[Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]] match + case '[Tuple14[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + val result: Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = x match + case '{ new Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14)) + case '{ Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14)) + case _ => None + result + + given tuple15FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15] => FromExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def apply()(using Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]): FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def unapply(x: Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]])(using Quotes): Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = summon[Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]] match + case '[Tuple15[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + val result: Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = x match + case '{ new Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15)) + case '{ Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15)) + case _ => None + result + + given tuple16FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16] => FromExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def apply()(using Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]): FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def unapply(x: Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]])(using Quotes): Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = summon[Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]] match + case '[Tuple16[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + given FromExpr[T16] = tf16.apply() + val result: Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = x match + case '{ new Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16)) + case '{ Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16)) + case _ => None + result + + given tuple17FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17] => FromExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def apply()(using Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]): FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def unapply(x: Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]])(using Quotes): Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = summon[Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]] match + case '[Tuple17[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + given FromExpr[T16] = tf16.apply() + given FromExpr[T17] = tf17.apply() + val result: Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = x match + case '{ new Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17)) + case '{ Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17)) + case _ => None + result + + given tuple18FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18] => FromExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def apply()(using Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]): FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def unapply(x: Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]])(using Quotes): Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = summon[Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]] match + case '[Tuple18[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + given FromExpr[T16] = tf16.apply() + given FromExpr[T17] = tf17.apply() + given FromExpr[T18] = tf18.apply() + val result: Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = x match + case '{ new Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18)) + case '{ Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18)) + case _ => None + result + + given tuple19FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19] => FromExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def apply()(using Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]): FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def unapply(x: Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]])(using Quotes): Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = summon[Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]] match + case '[Tuple19[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + given FromExpr[T16] = tf16.apply() + given FromExpr[T17] = tf17.apply() + given FromExpr[T18] = tf18.apply() + given FromExpr[T19] = tf19.apply() + val result: Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = x match + case '{ new Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19)) + case '{ Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19)) + case _ => None + result + + given tuple20FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19, T20: FromExprFactory as tf20] => FromExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def apply()(using Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]): FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def unapply(x: Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]])(using Quotes): Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = summon[Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]] match + case '[Tuple20[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + given FromExpr[T16] = tf16.apply() + given FromExpr[T17] = tf17.apply() + given FromExpr[T18] = tf18.apply() + given FromExpr[T19] = tf19.apply() + given FromExpr[T20] = tf20.apply() + val result: Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = x match + case '{ new Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20)) + case '{ Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20)) + case _ => None + result + + given tuple21FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19, T20: FromExprFactory as tf20, T21: FromExprFactory as tf21] => FromExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def apply()(using Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]): FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def unapply(x: Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]])(using Quotes): Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = summon[Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]] match + case '[Tuple21[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] + given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + given FromExpr[T16] = tf16.apply() + given FromExpr[T17] = tf17.apply() + given FromExpr[T18] = tf18.apply() + given FromExpr[T19] = tf19.apply() + given FromExpr[T20] = tf20.apply() + given FromExpr[T21] = tf21.apply() + val result: Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = x match + case '{ new Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21)) + case '{ Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21)) + case _ => None + result + + given tuple22FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19, T20: FromExprFactory as tf20, T21: FromExprFactory as tf21, T22: FromExprFactory as tf22] => FromExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def apply()(using Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]): FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = new FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def unapply(x: Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]])(using Quotes): Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = summon[Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]] match + case '[Tuple22[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] + given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] + given Type[T22] = Type.of[t22].asInstanceOf[Type[T22]] + given FromExpr[T1] = tf1.apply() + given FromExpr[T2] = tf2.apply() + given FromExpr[T3] = tf3.apply() + given FromExpr[T4] = tf4.apply() + given FromExpr[T5] = tf5.apply() + given FromExpr[T6] = tf6.apply() + given FromExpr[T7] = tf7.apply() + given FromExpr[T8] = tf8.apply() + given FromExpr[T9] = tf9.apply() + given FromExpr[T10] = tf10.apply() + given FromExpr[T11] = tf11.apply() + given FromExpr[T12] = tf12.apply() + given FromExpr[T13] = tf13.apply() + given FromExpr[T14] = tf14.apply() + given FromExpr[T15] = tf15.apply() + given FromExpr[T16] = tf16.apply() + given FromExpr[T17] = tf17.apply() + given FromExpr[T18] = tf18.apply() + given FromExpr[T19] = tf19.apply() + given FromExpr[T20] = tf20.apply() + given FromExpr[T21] = tf21.apply() + given FromExpr[T22] = tf22.apply() + val result: Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = x match + case '{ new Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}, ${Expr(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22)) + case '{ Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}, ${Expr(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22)) + case _ => None + result diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 8cd813ce6084..78f4d4c8dba2 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -105,17 +105,13 @@ object ToExpr extends LowPriorityToExpr { } } - /** Default implementation of `ToExpr[ClassTag[T]]`. */ - given ClassTagToExpr[T: Type]: ToExpr[ClassTag[T]] with { - def apply(ct: ClassTag[T])(using Quotes): Expr[ClassTag[T]] = - '{ ClassTag[T](${Expr(ct.runtimeClass.asInstanceOf[Class[T]])}) } - } + /** Default implementation of `ToExpr[ClassTag[T]]`. Proxies to `ToExprFactory.classTagToExprFactory`. */ + given ClassTagToExpr: [T: Type] => ToExpr[ClassTag[T]]: + def apply(ct: ClassTag[T])(using Quotes): Expr[ClassTag[T]] = summon[ToExprFactory[ClassTag[T]]].apply().apply(ct) - /** Default implementation of `ToExpr[Array[T]]`. */ - given ArrayToExpr[T: Type: ToExpr: ClassTag]: ToExpr[Array[T]] with { - def apply(arr: Array[T])(using Quotes): Expr[Array[T]] = - '{ Array[T](${Expr(arr.toSeq)}*)(using ${Expr(summon[ClassTag[T]])}) } - } + /** Default implementation of `ToExpr[Array[T]]`. Proxies to `ToExprFactory.arrayToExprFactory`. */ + given ArrayToExpr: [T: {Type, ToExpr, ClassTag}] => ToExpr[Array[T]]: + def apply(arr: Array[T])(using Quotes): Expr[Array[T]] = summon[ToExprFactory[Array[T]]].apply().apply(arr) /** Default implementation of `ToExpr[Array[Boolean]]`. */ given ArrayOfBooleanToExpr: ToExpr[Array[Boolean]] with { @@ -179,17 +175,13 @@ object ToExpr extends LowPriorityToExpr { '{ ${ltArray.apply(iarray.asInstanceOf[Array[T]])}.asInstanceOf[IArray[T]] } } - /** Default implementation of `ToExpr[Seq[T]]`. */ - given SeqToExpr[T: Type: ToExpr]: ToExpr[Seq[T]] with { - def apply(xs: Seq[T])(using Quotes): Expr[Seq[T]] = - Expr.ofSeq(xs.map(summon[ToExpr[T]].apply)) - } + /** Default implementation of `ToExpr[Seq[T]]`. Proxies to `ToExprFactory.seqToExprFactory`. */ + given SeqToExpr: [T: {Type, ToExpr}] => ToExpr[Seq[T]]: + def apply(xs: Seq[T])(using Quotes): Expr[Seq[T]] = summon[ToExprFactory[Seq[T]]].apply().apply(xs) - /** Default implementation of `ToExpr[List[T]]`. */ - given ListToExpr[T: Type: ToExpr]: ToExpr[List[T]] with { - def apply(xs: List[T])(using Quotes): Expr[List[T]] = - Expr.ofList(xs.map(summon[ToExpr[T]].apply)) - } + /** Default implementation of `ToExpr[List[T]]`. Proxies to `ToExprFactory.listToExprFactory`. */ + given ListToExpr: [T: {Type, ToExpr}] => ToExpr[List[T]]: + def apply(xs: List[T])(using Quotes): Expr[List[T]] = summon[ToExprFactory[List[T]]].apply().apply(xs) /** Default implementation of `ToExpr[Nil.type]`. */ given NilToExpr: ToExpr[Nil.type] with { @@ -197,31 +189,21 @@ object ToExpr extends LowPriorityToExpr { '{ Nil } } - /** Default implementation of `ToExpr[Set[T]]`. */ - given SetToExpr[T: Type: ToExpr]: ToExpr[Set[T]] with { - def apply(set: Set[T])(using Quotes): Expr[Set[T]] = - '{ Set(${Expr(set.toSeq)}*) } - } + /** Default implementation of `ToExpr[Set[T]]`. Proxies to `ToExprFactory.setToExprFactory`. */ + given SetToExpr: [T: {Type, ToExpr}] => ToExpr[Set[T]]: + def apply(xs: Set[T])(using Quotes): Expr[Set[T]] = summon[ToExprFactory[Set[T]]].apply().apply(xs) - /** Default implementation of `ToExpr[Map[T, U]]`. */ - given MapToExpr[T: Type: ToExpr, U: Type: ToExpr]: ToExpr[Map[T, U]] with { - def apply(map: Map[T, U])(using Quotes): Expr[Map[T, U]] = - '{ Map(${Expr(map.toSeq)}*) } - } + /** Default implementation of `ToExpr[Map[T, U]]`. Proxies to `ToExprFactory.mapToExprFactory`. */ + given MapToExpr: [T: {Type, ToExpr}, U: {Type, ToExpr}] => ToExpr[Map[T, U]]: + def apply(m: Map[T, U])(using Quotes): Expr[Map[T, U]] = summon[ToExprFactory[Map[T, U]]].apply().apply(m) - /** Default implementation of `ToExpr[Option[T]]`. */ - given OptionToExpr[T: Type: ToExpr]: ToExpr[Option[T]] with { - def apply(x: Option[T])(using Quotes): Expr[Option[T]] = x match { - case x: Some[T] => Expr(x) - case None => Expr(None) - } - } + /** Default implementation of `ToExpr[Option[T]]`. Proxies to `ToExprFactory.optionToExprFactory`. */ + given OptionToExpr: [T: {Type, ToExpr}] => ToExpr[Option[T]]: + def apply(x: Option[T])(using Quotes): Expr[Option[T]] = summon[ToExprFactory[Option[T]]].apply().apply(x) - /** Default implementation of `ToExpr[Some[T]]`. */ - given SomeToExpr[T: Type: ToExpr]: ToExpr[Some[T]] with { - def apply(x: Some[T])(using Quotes): Expr[Some[T]] = - '{ Some[T](${Expr(x.get)}) } - } + /** Default implementation of `ToExpr[Some[T]]`. Proxies to `ToExprFactory.someToExprFactory`. */ + given SomeToExpr: [T: {Type, ToExpr}] => ToExpr[Some[T]]: + def apply(x: Some[T])(using Quotes): Expr[Some[T]] = summon[ToExprFactory[Some[T]]].apply().apply(x) /** Default implementation of `ToExpr[None.type]`. */ given NoneToExpr: ToExpr[None.type] with { @@ -229,24 +211,17 @@ object ToExpr extends LowPriorityToExpr { '{ None } } - /** Default implementation of `ToExpr[Either[L, R]]`. */ - given EitherToExpr[L: Type: ToExpr, R: Type: ToExpr]: ToExpr[Either[L, R]] with { - def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = x match - case x: Left[L, R] => Expr(x) - case x: Right[L, R] => Expr(x) - } + /** Default implementation of `ToExpr[Either[L, R]]`. Proxies to `ToExprFactory.eitherToExprFactory`. */ + given EitherToExpr: [L: {Type, ToExpr}, R: {Type, ToExpr}] => ToExpr[Either[L, R]]: + def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = summon[ToExprFactory[Either[L, R]]].apply().apply(x) - /** Default implementation of `ToExpr[Left[L, R]]`. */ - given LeftToExpr[L: Type: ToExpr, R: Type]: ToExpr[Left[L, R]] with { - def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = - '{ Left[L, R](${Expr(x.value)}) } - } + /** Default implementation of `ToExpr[Left[L, R]]`. Proxies to `ToExprFactory.leftToExprFactory`. */ + given LeftToExpr: [L: {Type, ToExpr}, R: Type] => ToExpr[Left[L, R]]: + def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = summon[ToExprFactory[Left[L, R]]].apply().apply(x) - /** Default implementation of `ToExpr[Right[L, R]]`. */ - given RightToExpr[L: Type, R: Type: ToExpr]: ToExpr[Right[L, R]] with { - def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = - '{ Right[L, R](${Expr(x.value)}) } - } + /** Default implementation of `ToExpr[Right[L, R]]`. Proxies to `ToExprFactory.rightToExprFactory`. */ + given RightToExpr: [L: Type, R: {Type, ToExpr}] => ToExpr[Right[L, R]]: + def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = summon[ToExprFactory[Right[L, R]]].apply().apply(x) /** Default implementation of `ToExpr[EmptyTuple.type]`. */ given EmptyTupleToExpr: ToExpr[EmptyTuple.type] with { diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index 9726c0097428..0f206736d942 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -2,6 +2,7 @@ package scala.quoted import language.experimental.captureChecking import scala.deriving.Mirror +import scala.reflect.ClassTag /** A factory that, given a `Type[T]`, produces a `ToExpr[T]`. * @@ -57,5 +58,761 @@ object ToExprFactory: case '[c] => elems(idx).asInstanceOf[ToExprFactory[c]].apply().apply(x.asInstanceOf[c]).asInstanceOf[Expr[T]] /** Bridges any type that already has a plain `ToExpr` (e.g. `Int`, `String`) into `ToExprFactory`. */ - given [T] => (te: ToExpr[T]) => ToExprFactory[T]: + given fromToExpr: [T] => (te: ToExpr[T]) => ToExprFactory[T]: def apply()(using Type[T]): ToExpr[T] = te + + // Container instances below defer `Type[T]` the same way `derivedProduct`/`derivedSum` do: + // they only need a `ToExprFactory` for the element type(s), not a `Type` for them, so they + // stay usable as fields of a `derives ToExprFactory` type without forcing `(using Quotes)` + // on the enclosing given. Each decomposes its own `Type[Xxx[T]]` via a quote type pattern to + // recover `Type[T]`; the cast is safe since the pattern only ever matches with `t =:= T`. + + given classTagToExprFactory: [T] => ToExprFactory[ClassTag[T]]: + def apply()(using Type[ClassTag[T]]): ToExpr[ClassTag[T]] = new ToExpr[ClassTag[T]]: + def apply(ct: ClassTag[T])(using Quotes): Expr[ClassTag[T]] = summon[Type[ClassTag[T]]] match + case '[ClassTag[t]] => + '{ ClassTag[t](${Expr(ct.runtimeClass.asInstanceOf[Class[t]])}) }.asInstanceOf[Expr[ClassTag[T]]] + + given arrayToExprFactory: [T: {ToExprFactory as tf, ClassTag as ct}] => ToExprFactory[Array[T]]: + def apply()(using Type[Array[T]]): ToExpr[Array[T]] = new ToExpr[Array[T]]: + def apply(arr: Array[T])(using Quotes): Expr[Array[T]] = summon[Type[Array[T]]] match + case '[Array[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val te = tf.apply() + val elemExprs = Expr.ofSeq(arr.toSeq.map(te.apply)) + '{ Array[T]($elemExprs*)(using ${Expr(ct)}) } + + given seqToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Seq[T]]: + def apply()(using Type[Seq[T]]): ToExpr[Seq[T]] = new ToExpr[Seq[T]]: + def apply(xs: Seq[T])(using Quotes): Expr[Seq[T]] = summon[Type[Seq[T]]] match + case '[Seq[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val te = tf.apply() + Expr.ofSeq(xs.map(te.apply)) + + given listToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[List[T]]: + def apply()(using Type[List[T]]): ToExpr[List[T]] = new ToExpr[List[T]]: + def apply(xs: List[T])(using Quotes): Expr[List[T]] = summon[Type[List[T]]] match + case '[List[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val te = tf.apply() + Expr.ofList(xs.map(te.apply)) + + given setToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Set[T]]: + def apply()(using Type[Set[T]]): ToExpr[Set[T]] = new ToExpr[Set[T]]: + def apply(xs: Set[T])(using Quotes): Expr[Set[T]] = summon[Type[Set[T]]] match + case '[Set[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val te = tf.apply() + val elemExprs = Expr.ofSeq(xs.toSeq.map(te.apply)) + '{ Set($elemExprs*) } + + given mapToExprFactory: [T: ToExprFactory as tf, U: ToExprFactory as uf] => ToExprFactory[Map[T, U]]: + def apply()(using Type[Map[T, U]]): ToExpr[Map[T, U]] = new ToExpr[Map[T, U]]: + def apply(m: Map[T, U])(using Quotes): Expr[Map[T, U]] = summon[Type[Map[T, U]]] match + case '[Map[t, u]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + given Type[U] = Type.of[u].asInstanceOf[Type[U]] + val te = tf.apply() + val ue = uf.apply() + val pairs = m.toSeq.map((k, v) => '{ (${te.apply(k)}, ${ue.apply(v)}) }) + '{ Map(${Expr.ofSeq(pairs)}*) } + + given optionToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Option[T]]: + def apply()(using Type[Option[T]]): ToExpr[Option[T]] = new ToExpr[Option[T]]: + def apply(x: Option[T])(using Quotes): Expr[Option[T]] = summon[Type[Option[T]]] match + case '[Option[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val te = tf.apply() + x match + case Some(v) => '{ Some[T](${te.apply(v)}) } + case None => '{ None } + + given someToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Some[T]]: + def apply()(using Type[Some[T]]): ToExpr[Some[T]] = new ToExpr[Some[T]]: + def apply(x: Some[T])(using Quotes): Expr[Some[T]] = summon[Type[Some[T]]] match + case '[Some[t]] => + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val te = tf.apply() + '{ Some[T](${te.apply(x.get)}) } + + given eitherToExprFactory: [L: ToExprFactory as lf, R: ToExprFactory as rf] => ToExprFactory[Either[L, R]]: + def apply()(using Type[Either[L, R]]): ToExpr[Either[L, R]] = new ToExpr[Either[L, R]]: + def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = summon[Type[Either[L, R]]] match + case '[Either[l, r]] => + given Type[L] = Type.of[l].asInstanceOf[Type[L]] + given Type[R] = Type.of[r].asInstanceOf[Type[R]] + val le = lf.apply() + val re = rf.apply() + x match + case scala.util.Left(v) => '{ Left[L, R](${le.apply(v)}) } + case scala.util.Right(v) => '{ Right[L, R](${re.apply(v)}) } + + given leftToExprFactory: [L: ToExprFactory as lf, R] => ToExprFactory[Left[L, R]]: + def apply()(using Type[Left[L, R]]): ToExpr[Left[L, R]] = new ToExpr[Left[L, R]]: + def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = summon[Type[Left[L, R]]] match + case '[Left[l, r]] => + given Type[L] = Type.of[l].asInstanceOf[Type[L]] + given Type[R] = Type.of[r].asInstanceOf[Type[R]] + val le = lf.apply() + '{ Left[L, R](${le.apply(x.value)}) } + + given rightToExprFactory: [L, R: ToExprFactory as rf] => ToExprFactory[Right[L, R]]: + def apply()(using Type[Right[L, R]]): ToExpr[Right[L, R]] = new ToExpr[Right[L, R]]: + def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = summon[Type[Right[L, R]]] match + case '[Right[l, r]] => + given Type[L] = Type.of[l].asInstanceOf[Type[L]] + given Type[R] = Type.of[r].asInstanceOf[Type[R]] + val re = rf.apply() + '{ Right[L, R](${re.apply(x.value)}) } + + // Tuple instances: same deferred-Type pattern as the containers above, mirroring the + // hand-written Tuple1..22/TupleCons instances in ToExprFactory/FromExprFactory. + + given tuple1ToExprFactory: [T1: ToExprFactory as tf1] => ToExprFactory[Tuple1[T1]]: + def apply()(using Type[Tuple1[T1]]): ToExpr[Tuple1[T1]] = new ToExpr[Tuple1[T1]]: + def apply(tup: Tuple1[T1])(using Quotes): Expr[Tuple1[T1]] = summon[Type[Tuple1[T1]]] match + case '[Tuple1[t1]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + val e1 = tf1.apply().apply(tup._1) + '{ Tuple1(${e1}) } + + given tuple2ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2] => ToExprFactory[Tuple2[T1, T2]]: + def apply()(using Type[Tuple2[T1, T2]]): ToExpr[Tuple2[T1, T2]] = new ToExpr[Tuple2[T1, T2]]: + def apply(tup: Tuple2[T1, T2])(using Quotes): Expr[Tuple2[T1, T2]] = summon[Type[Tuple2[T1, T2]]] match + case '[Tuple2[t1, t2]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + '{ (${e1}, ${e2}) } + + given tuple3ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3] => ToExprFactory[Tuple3[T1, T2, T3]]: + def apply()(using Type[Tuple3[T1, T2, T3]]): ToExpr[Tuple3[T1, T2, T3]] = new ToExpr[Tuple3[T1, T2, T3]]: + def apply(tup: Tuple3[T1, T2, T3])(using Quotes): Expr[Tuple3[T1, T2, T3]] = summon[Type[Tuple3[T1, T2, T3]]] match + case '[Tuple3[t1, t2, t3]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + '{ (${e1}, ${e2}, ${e3}) } + + given tuple4ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4] => ToExprFactory[Tuple4[T1, T2, T3, T4]]: + def apply()(using Type[Tuple4[T1, T2, T3, T4]]): ToExpr[Tuple4[T1, T2, T3, T4]] = new ToExpr[Tuple4[T1, T2, T3, T4]]: + def apply(tup: Tuple4[T1, T2, T3, T4])(using Quotes): Expr[Tuple4[T1, T2, T3, T4]] = summon[Type[Tuple4[T1, T2, T3, T4]]] match + case '[Tuple4[t1, t2, t3, t4]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + '{ (${e1}, ${e2}, ${e3}, ${e4}) } + + given tuple5ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5] => ToExprFactory[Tuple5[T1, T2, T3, T4, T5]]: + def apply()(using Type[Tuple5[T1, T2, T3, T4, T5]]): ToExpr[Tuple5[T1, T2, T3, T4, T5]] = new ToExpr[Tuple5[T1, T2, T3, T4, T5]]: + def apply(tup: Tuple5[T1, T2, T3, T4, T5])(using Quotes): Expr[Tuple5[T1, T2, T3, T4, T5]] = summon[Type[Tuple5[T1, T2, T3, T4, T5]]] match + case '[Tuple5[t1, t2, t3, t4, t5]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}) } + + given tuple6ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6] => ToExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]: + def apply()(using Type[Tuple6[T1, T2, T3, T4, T5, T6]]): ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]] = new ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: + def apply(tup: Tuple6[T1, T2, T3, T4, T5, T6])(using Quotes): Expr[Tuple6[T1, T2, T3, T4, T5, T6]] = summon[Type[Tuple6[T1, T2, T3, T4, T5, T6]]] match + case '[Tuple6[t1, t2, t3, t4, t5, t6]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}) } + + given tuple7ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7] => ToExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def apply()(using Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]): ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def apply(tup: Tuple7[T1, T2, T3, T4, T5, T6, T7])(using Quotes): Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = summon[Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]] match + case '[Tuple7[t1, t2, t3, t4, t5, t6, t7]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}) } + + given tuple8ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8] => ToExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def apply()(using Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]): ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def apply(tup: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8])(using Quotes): Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = summon[Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]] match + case '[Tuple8[t1, t2, t3, t4, t5, t6, t7, t8]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}) } + + given tuple9ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9] => ToExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def apply()(using Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]): ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def apply(tup: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9])(using Quotes): Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = summon[Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]] match + case '[Tuple9[t1, t2, t3, t4, t5, t6, t7, t8, t9]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}) } + + given tuple10ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10] => ToExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def apply()(using Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]): ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def apply(tup: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10])(using Quotes): Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = summon[Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]] match + case '[Tuple10[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}) } + + given tuple11ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11] => ToExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def apply()(using Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]): ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def apply(tup: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11])(using Quotes): Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = summon[Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]] match + case '[Tuple11[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}) } + + given tuple12ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12] => ToExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def apply()(using Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]): ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def apply(tup: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12])(using Quotes): Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = summon[Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]] match + case '[Tuple12[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}) } + + given tuple13ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13] => ToExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def apply()(using Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]): ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def apply(tup: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13])(using Quotes): Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = summon[Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]] match + case '[Tuple13[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}) } + + given tuple14ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14] => ToExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def apply()(using Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]): ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def apply(tup: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14])(using Quotes): Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = summon[Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]] match + case '[Tuple14[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}) } + + given tuple15ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15] => ToExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def apply()(using Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]): ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def apply(tup: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15])(using Quotes): Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = summon[Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]] match + case '[Tuple15[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}) } + + given tuple16ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16] => ToExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def apply()(using Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]): ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def apply(tup: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16])(using Quotes): Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = summon[Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]] match + case '[Tuple16[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + val e16 = tf16.apply().apply(tup._16) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}) } + + given tuple17ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17] => ToExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def apply()(using Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]): ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def apply(tup: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17])(using Quotes): Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = summon[Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]] match + case '[Tuple17[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + val e16 = tf16.apply().apply(tup._16) + val e17 = tf17.apply().apply(tup._17) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}) } + + given tuple18ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18] => ToExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def apply()(using Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]): ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def apply(tup: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18])(using Quotes): Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = summon[Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]] match + case '[Tuple18[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + val e16 = tf16.apply().apply(tup._16) + val e17 = tf17.apply().apply(tup._17) + val e18 = tf18.apply().apply(tup._18) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}) } + + given tuple19ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19] => ToExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def apply()(using Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]): ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def apply(tup: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19])(using Quotes): Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = summon[Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]] match + case '[Tuple19[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + val e16 = tf16.apply().apply(tup._16) + val e17 = tf17.apply().apply(tup._17) + val e18 = tf18.apply().apply(tup._18) + val e19 = tf19.apply().apply(tup._19) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}) } + + given tuple20ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19, T20: ToExprFactory as tf20] => ToExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def apply()(using Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]): ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def apply(tup: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20])(using Quotes): Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = summon[Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]] match + case '[Tuple20[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + val e16 = tf16.apply().apply(tup._16) + val e17 = tf17.apply().apply(tup._17) + val e18 = tf18.apply().apply(tup._18) + val e19 = tf19.apply().apply(tup._19) + val e20 = tf20.apply().apply(tup._20) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}, ${e20}) } + + given tuple21ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19, T20: ToExprFactory as tf20, T21: ToExprFactory as tf21] => ToExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def apply()(using Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]): ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def apply(tup: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21])(using Quotes): Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = summon[Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]] match + case '[Tuple21[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] + given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + val e16 = tf16.apply().apply(tup._16) + val e17 = tf17.apply().apply(tup._17) + val e18 = tf18.apply().apply(tup._18) + val e19 = tf19.apply().apply(tup._19) + val e20 = tf20.apply().apply(tup._20) + val e21 = tf21.apply().apply(tup._21) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}, ${e20}, ${e21}) } + + given tuple22ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19, T20: ToExprFactory as tf20, T21: ToExprFactory as tf21, T22: ToExprFactory as tf22] => ToExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def apply()(using Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]): ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = new ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def apply(tup: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22])(using Quotes): Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = summon[Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]] match + case '[Tuple22[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22]] => + given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] + given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] + given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] + given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] + given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] + given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] + given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] + given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] + given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] + given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] + given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] + given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] + given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] + given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] + given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] + given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] + given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] + given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] + given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] + given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] + given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] + given Type[T22] = Type.of[t22].asInstanceOf[Type[T22]] + val e1 = tf1.apply().apply(tup._1) + val e2 = tf2.apply().apply(tup._2) + val e3 = tf3.apply().apply(tup._3) + val e4 = tf4.apply().apply(tup._4) + val e5 = tf5.apply().apply(tup._5) + val e6 = tf6.apply().apply(tup._6) + val e7 = tf7.apply().apply(tup._7) + val e8 = tf8.apply().apply(tup._8) + val e9 = tf9.apply().apply(tup._9) + val e10 = tf10.apply().apply(tup._10) + val e11 = tf11.apply().apply(tup._11) + val e12 = tf12.apply().apply(tup._12) + val e13 = tf13.apply().apply(tup._13) + val e14 = tf14.apply().apply(tup._14) + val e15 = tf15.apply().apply(tup._15) + val e16 = tf16.apply().apply(tup._16) + val e17 = tf17.apply().apply(tup._17) + val e18 = tf18.apply().apply(tup._18) + val e19 = tf19.apply().apply(tup._19) + val e20 = tf20.apply().apply(tup._20) + val e21 = tf21.apply().apply(tup._21) + val e22 = tf22.apply().apply(tup._22) + '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}, ${e20}, ${e21}, ${e22}) } + + given tupleConsToExprFactory: [H: ToExprFactory as hf, T <: Tuple: ToExprFactory as tf] => ToExprFactory[H *: T]: + def apply()(using Type[H *: T]): ToExpr[H *: T] = new ToExpr[H *: T]: + def apply(tup: H *: T)(using Quotes): Expr[H *: T] = summon[Type[H *: T]] match + case '[h *: t] => + given Type[H] = Type.of[h].asInstanceOf[Type[H]] + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val head = hf.apply().apply(tup.head) + val tail = tf.apply().apply(tup.tail) + '{ $head *: $tail } diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala index af9176320398..165eaed6c43e 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -30,6 +30,15 @@ case object Singleton derives ToExprFactory, FromExprFactory // Generic product (needs an explicit Type/instance bound) case class Box[A](value: A) derives FromExprFactory, ToExprFactory +// Container-typed fields, now handled by dedicated container Factory instances +case class Tagged(tags: List[Int]) derives ToExprFactory, FromExprFactory +case class WithOpt(o: Option[String]) derives ToExprFactory, FromExprFactory +case class WithEither(e: Either[Int, String]) derives ToExprFactory, FromExprFactory +case class WithMap(m: Map[String, Int]) derives ToExprFactory, FromExprFactory +case class WithSet(s: Set[Long]) derives ToExprFactory, FromExprFactory +case class WithArray(a: Array[Int]) derives ToExprFactory, FromExprFactory +case class WithTuple(a: (Int, List[String])) derives ToExprFactory, FromExprFactory + // Sum: sealed trait + cases, auto-derived sealed trait Shape derives ToExprFactory, FromExprFactory object Shape: @@ -133,11 +142,17 @@ object Macro: // ToExpr -> FromExpr round trip, all cases above inline def roundTrips: Boolean = ${ Macro.roundTripsImpl } - private def check[T: Type: FromExpr](expr: Expr[T], expected: T)(using Quotes): Expr[Boolean] = - Expr(summon[FromExpr[T]].unapply(expr) == Some(expected)) + // Container-typed fields, round trip without any ambient Quotes given + inline def roundTripsContainers: Boolean = ${ Macro.roundTripsContainersImpl } + + // Direct coverage of tuple1ToExprFactory..tuple22ToExprFactory / tuple1FromExprFactory..tuple22FromExprFactory + inline def roundTripsTupleFactories: Boolean = ${ Macro.roundTripsTupleFactoriesImpl } + + private def check[T: {Type, FromExpr as fe}](expr: Expr[T], expected: T)(using Quotes): Expr[Boolean] = + Expr(fe.unapply(expr) == Some(expected)) - private def checkNone[T: Type: FromExpr](expr: Expr[T])(using Quotes): Expr[Boolean] = - Expr(summon[FromExpr[T]].unapply(expr).isEmpty) + private def checkNone[T: {Type, FromExpr as fe}](expr: Expr[T])(using Quotes): Expr[Boolean] = + Expr(fe.unapply(expr).isEmpty) def matchApplyPointImpl(using Quotes): Expr[Boolean] = check('{ Point(1, 2) }, Point(1, 2)) def matchNewPointImpl(using Quotes): Expr[Boolean] = check('{ new Point(1, 2) }, Point(1, 2)) @@ -204,8 +219,7 @@ object Macro: checkNone(e.asInstanceOf[Expr[Shape.Rect]]) def wrongArityIsNoneImpl(using Quotes): Expr[Boolean] = - val e: Expr[Point] = Expr(Point(1, 2)) - checkNone(e.asInstanceOf[Expr[Mixed]]) + checkNone(Expr(Point(1, 2)).asInstanceOf[Expr[Mixed]]) def roundTripBig25IsNoneImpl(using Quotes): Expr[Boolean] = val original = Big25(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25) @@ -223,8 +237,8 @@ object Macro: Expr(tuple5FromExpr.unapply(tuple5ToExpr(original)) == Some(original)) def roundTripsImpl(using Quotes): Expr[Boolean] = - def roundTrip[T: Type: ToExpr: FromExpr](original: T): Boolean = - summon[FromExpr[T]].unapply(Expr(original)) == Some(original) + def roundTrip[T: {Type, ToExpr, FromExpr as fe}](original: T): Boolean = + fe.unapply(Expr(original)) == Some(original) Expr( roundTrip(Point(1, 2)) && roundTrip(Mixed("m", true, 1.5)) @@ -242,3 +256,49 @@ object Macro: && roundTrip[Vehicle](Vehicle.Bicycle(21)) && roundTrip(Arith.Add(Arith.Lit(1), Arith.Neg(Arith.Add(Arith.Lit(2), Arith.Lit(3))))) ) + + def roundTripsContainersImpl(using Quotes): Expr[Boolean] = + def roundTrip[T: {Type, ToExpr, FromExpr as fe}](original: T): Boolean = + fe.unapply(Expr(original)) == Some(original) + val arrayBack = summon[FromExpr[WithArray]].unapply(Expr(WithArray(Array(1, 2, 3)))) + Expr( + roundTrip(Tagged(List(1, 2, 3))) + && roundTrip(WithOpt(Some("hi"))) + && roundTrip(WithOpt(None)) + && roundTrip(WithEither(Left(5): Either[Int, String])) + && roundTrip(WithEither(Right("r"): Either[Int, String])) + && roundTrip(WithMap(Map("a" -> 1, "b" -> 2))) + && roundTrip(WithSet(Set(1L, 2L))) + && roundTrip(WithTuple((1, List("a", "b")))) + && arrayBack.exists(_.a.sameElements(Array(1, 2, 3))) + ) + + def roundTripsTupleFactoriesImpl(using Quotes): Expr[Boolean] = + def roundTripFactory[T: {Type, ToExprFactory as tef, FromExprFactory as fef}](original: T): Boolean = + val te = tef.apply() + val fe = fef.apply() + fe.unapply(te.apply(original)) == Some(original) + Expr( + roundTripFactory(Tuple1(1)) + && roundTripFactory((1, 2)) + && roundTripFactory((1, 2, 3)) + && roundTripFactory((1, 2, 3, 4)) + && roundTripFactory((1, 2, 3, 4, 5)) + && roundTripFactory((1, 2, 3, 4, 5, 6)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)) + && roundTripFactory((1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)) + ) diff --git a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala index 0c684f8122e6..4bc8b15d0f38 100644 --- a/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala @@ -35,3 +35,5 @@ object Test: assert(Macro.matchTuple2, "matchTuple2") assert(Macro.roundTripTuple5, "roundTripTuple5") assert(Macro.roundTrips, "roundTrips") + assert(Macro.roundTripsContainers, "roundTripsContainers") + assert(Macro.roundTripsTupleFactories, "roundTripsTupleFactories") diff --git a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala index afe61a19fb26..8ff228418c26 100644 --- a/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala @@ -17,9 +17,14 @@ case class Box[A](value: A) derives ToExprFactory // Product, mixed field kinds case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExprFactory -// Field type (List[Int]) whose ToExpr needs Quotes ambient, not just Type/instance -case class Tagged(tags: List[Int]) -given taggedToExpr(using Quotes): ToExpr[Tagged] = ToExprFactory.derived[Tagged].apply() +// Container-typed fields, now handled by dedicated container ToExprFactory instances +case class Tagged(tags: List[Int]) derives ToExprFactory +case class WithOpt(o: Option[String]) derives ToExprFactory +case class WithEither(e: Either[Int, String]) derives ToExprFactory +case class WithMap(m: Map[String, Int]) derives ToExprFactory +case class WithSet(s: Set[Long]) derives ToExprFactory +case class WithArray(a: Array[Int]) derives ToExprFactory +case class WithTuple(a: (Int, List[String])) derives ToExprFactory // Sum: sealed trait + cases, auto-derived sealed trait Shape derives ToExprFactory @@ -57,6 +62,15 @@ object Macro: inline def liftBoxBox: Box[Box[Int]] = ${ Macro.liftBoxBoxImpl } inline def liftMixed: Mixed = ${ Macro.liftMixedImpl } inline def liftTagged: Tagged = ${ Macro.liftTaggedImpl } + inline def liftWithOpt: WithOpt = ${ Macro.liftWithOptImpl } + inline def liftWithEither: WithEither = ${ Macro.liftWithEitherImpl } + inline def liftWithMap: WithMap = ${ Macro.liftWithMapImpl } + inline def liftWithSet: WithSet = ${ Macro.liftWithSetImpl } + inline def showWithArrayTree: String = ${ Macro.showWithArrayTreeImpl } + inline def liftWithTuple: WithTuple = ${ Macro.liftWithTupleImpl } + + // Direct coverage of tupleConsToExprFactory (`H *: T`); no FromExprFactory counterpart exists + inline def showTupleConsTree: String = ${ Macro.showTupleConsTreeImpl } inline def liftCircle: Shape.Circle = ${ Macro.liftCircleImpl } inline def liftShapeCircle: Shape = ${ Macro.liftShapeCircleImpl } inline def liftShapeRect: Shape = ${ Macro.liftShapeRectImpl } @@ -81,6 +95,15 @@ object Macro: def liftBoxBoxImpl(using Quotes): Expr[Box[Box[Int]]] = Expr(Box(Box(1))) def liftMixedImpl(using Quotes): Expr[Mixed] = Expr(Mixed("m", true, 1.5)) def liftTaggedImpl(using Quotes): Expr[Tagged] = Expr(Tagged(List(1, 2, 3))) + def liftWithOptImpl(using Quotes): Expr[WithOpt] = Expr(WithOpt(Some("hi"))) + def liftWithEitherImpl(using Quotes): Expr[WithEither] = Expr(WithEither(Left(5))) + def liftWithMapImpl(using Quotes): Expr[WithMap] = Expr(WithMap(Map("a" -> 1, "b" -> 2))) + def liftWithSetImpl(using Quotes): Expr[WithSet] = Expr(WithSet(Set(1L, 2L))) + def showWithArrayTreeImpl(using Quotes): Expr[String] = Expr(Expr(WithArray(Array(1, 2, 3))).show) + def liftWithTupleImpl(using Quotes): Expr[WithTuple] = Expr(WithTuple((1, List("a", "b")))) + def showTupleConsTreeImpl(using Quotes): Expr[String] = + val cons: Int *: (String, Double) = 1 *: ("a", 2.5) + Expr(summon[ToExprFactory[Int *: (String, Double)]].apply().apply(cons).show) def liftCircleImpl(using Quotes): Expr[Shape.Circle] = // `Circle` has no standalone top-level `ToExpr` (auto-derived via `Shape`), so derive locally given ToExpr[Shape.Circle] = ToExprFactory.derived[Shape.Circle].apply() diff --git a/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala b/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala index fc49cf73127f..441c97c1543a 100644 --- a/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala @@ -8,6 +8,13 @@ object Test: assert(Macro.liftBoxBox == Box(Box(1)), Macro.liftBoxBox) assert(Macro.liftMixed == Mixed("m", true, 1.5), Macro.liftMixed) assert(Macro.liftTagged == Tagged(List(1, 2, 3)), Macro.liftTagged) + assert(Macro.liftWithOpt == WithOpt(Some("hi")), Macro.liftWithOpt) + assert(Macro.liftWithEither == WithEither(Left(5)), Macro.liftWithEither) + assert(Macro.liftWithMap == WithMap(Map("a" -> 1, "b" -> 2)), Macro.liftWithMap) + assert(Macro.liftWithSet == WithSet(Set(1L, 2L)), Macro.liftWithSet) + assert(Macro.showWithArrayTree.contains("Array"), Macro.showWithArrayTree) + assert(Macro.liftWithTuple == WithTuple((1, List("a", "b"))), Macro.liftWithTuple) + assert(Macro.showTupleConsTree.contains("2.5"), Macro.showTupleConsTree) assert(Macro.liftCircle == Shape.Circle(1.0), Macro.liftCircle) assert(Macro.liftShapeCircle == Shape.Circle(2.0), Macro.liftShapeCircle) assert(Macro.liftShapeRect == Shape.Rect(1.0, 2.0), Macro.liftShapeRect) From 05a51dcf6549ed90e2f9a7bdf1b88a75ddc54005 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Wed, 15 Jul 2026 17:05:23 +0200 Subject: [PATCH 12/17] Simplify ToExprFactory/FromExprFactory: drop redundant ToExpr/FromExpr bindings The explicit `given FromExpr[T] = tf.apply()` (and `val te = tf.apply()` on the ToExpr side) in the container/tuple instances were dead weight: the existing fromToExpr/fromFromExpr bridges already synthesize a ToExpr[T]/FromExpr[T] implicitly from the in-scope Type[T] and ToExprFactory[T]/FromExprFactory[T], so plain `Expr(x)` / `Expr.unapply` calls resolve the same instance without the extra binding. Also inlines the tuple factories' per-element `val eN = ...` into the final tuple literal, and drops the now-unused `as name` bindings from context bounds where the name was only needed for those redundant lines. Co-Authored-By: Claude Sonnet 5 --- .../src/scala/quoted/FromExprFactory.scala | 329 ++----------- library/src/scala/quoted/ToExprFactory.scala | 459 +++++------------- 2 files changed, 140 insertions(+), 648 deletions(-) diff --git a/library/src/scala/quoted/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala index a0a0b7ef9ec1..39ec4a61bb11 100644 --- a/library/src/scala/quoted/FromExprFactory.scala +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -100,23 +100,21 @@ object FromExprFactory: // Each decomposes its own `Type[Xxx[T]]` via a quote type pattern to recover `Type[T]`; the // cast is safe since the pattern only ever matches with `t =:= T`. - given arrayFromExprFactory: [T: {FromExprFactory as tf, ClassTag as ct}] => FromExprFactory[Array[T]]: + given arrayFromExprFactory: [T: {FromExprFactory, ClassTag as ct}] => FromExprFactory[Array[T]]: def apply()(using Type[Array[T]]): FromExpr[Array[T]] = new FromExpr[Array[T]]: def unapply(x: Expr[Array[T]])(using Quotes): Option[Array[T]] = summon[Type[Array[T]]] match case '[Array[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - given FromExpr[T] = tf.apply() val result: Option[Array[T]] = x match case '{ Array[T](${Varargs(Exprs(elems))}*)(using ${_}) } => Some(elems.toArray(using ct)) case _ => None result - given seqFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Seq[T]]: + given seqFromExprFactory: [T: FromExprFactory] => FromExprFactory[Seq[T]]: def apply()(using Type[Seq[T]]): FromExpr[Seq[T]] = new FromExpr[Seq[T]]: def unapply(x: Expr[Seq[T]])(using Quotes): Option[Seq[T]] = summon[Type[Seq[T]]] match case '[Seq[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - given FromExpr[T] = tf.apply() val result: Option[Seq[T]] = x match case Varargs(Exprs(elems)) => Some(elems) case '{ scala.Seq[T](${Varargs(Exprs(elems))}*) } => Some(elems) @@ -125,12 +123,11 @@ object FromExprFactory: case _ => None result - given listFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[List[T]]: + given listFromExprFactory: [T: FromExprFactory] => FromExprFactory[List[T]]: def apply()(using Type[List[T]]): FromExpr[List[T]] = new FromExpr[List[T]]: def unapply(x: Expr[List[T]])(using Quotes): Option[List[T]] = summon[Type[List[T]]] match case '[List[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - given FromExpr[T] = tf.apply() val result: Option[List[T]] = x match case '{ scala.List[T](${Varargs(Exprs(elems))}*) } => Some(elems.toList) case '{ scala.List.empty[T] } => Some(Nil) @@ -140,12 +137,11 @@ object FromExprFactory: case _ => None result - given setFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Set[T]]: + given setFromExprFactory: [T: FromExprFactory] => FromExprFactory[Set[T]]: def apply()(using Type[Set[T]]): FromExpr[Set[T]] = new FromExpr[Set[T]]: def unapply(x: Expr[Set[T]])(using Quotes): Option[Set[T]] = summon[Type[Set[T]]] match case '[Set[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - given FromExpr[T] = tf.apply() val result: Option[Set[T]] = x match case '{ Set[T](${Varargs(Exprs(elems))}*) } => Some(elems.toSet) case '{ Set.empty[T] } => Some(Set.empty[T]) @@ -154,14 +150,12 @@ object FromExprFactory: case _ => None result - given mapFromExprFactory: [T: FromExprFactory as tf, U: FromExprFactory as uf] => FromExprFactory[Map[T, U]]: + given mapFromExprFactory: [T: FromExprFactory, U: FromExprFactory] => FromExprFactory[Map[T, U]]: def apply()(using Type[Map[T, U]]): FromExpr[Map[T, U]] = new FromExpr[Map[T, U]]: def unapply(x: Expr[Map[T, U]])(using Quotes): Option[Map[T, U]] = summon[Type[Map[T, U]]] match case '[Map[t, u]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] given Type[U] = Type.of[u].asInstanceOf[Type[U]] - given FromExpr[T] = tf.apply() - given FromExpr[U] = uf.apply() val result: Option[Map[T, U]] = x match case '{ Map[T, U](${Varargs(Exprs(elems))}*) } => Some(elems.toMap) case '{ Map.empty[T, U] } => Some(Map.empty) @@ -170,12 +164,11 @@ object FromExprFactory: case _ => None result - given optionFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Option[T]]: + given optionFromExprFactory: [T: FromExprFactory] => FromExprFactory[Option[T]]: def apply()(using Type[Option[T]]): FromExpr[Option[T]] = new FromExpr[Option[T]]: def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] = summon[Type[Option[T]]] match case '[Option[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - given FromExpr[T] = tf.apply() val result: Option[Option[T]] = x match case '{ Option[T](${Expr(y)}: T) } => Some(Option(y)) case '{ None } => Some(None) @@ -183,51 +176,46 @@ object FromExprFactory: case _ => None result - given someFromExprFactory: [T: FromExprFactory as tf] => FromExprFactory[Some[T]]: + given someFromExprFactory: [T: FromExprFactory] => FromExprFactory[Some[T]]: def apply()(using Type[Some[T]]): FromExpr[Some[T]] = new FromExpr[Some[T]]: def unapply(x: Expr[Some[T]])(using Quotes): Option[Some[T]] = summon[Type[Some[T]]] match case '[Some[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - given FromExpr[T] = tf.apply() val result: Option[Some[T]] = x match case '{ new Some[T](${Expr(y)}) } => Some(Some(y)) case '{ Some[T](${Expr(y)}) } => Some(Some(y)) case _ => None result - given eitherFromExprFactory: [L: FromExprFactory as lf, R: FromExprFactory as rf] => FromExprFactory[Either[L, R]]: + given eitherFromExprFactory: [L: FromExprFactory, R: FromExprFactory] => FromExprFactory[Either[L, R]]: def apply()(using Type[Either[L, R]]): FromExpr[Either[L, R]] = new FromExpr[Either[L, R]]: def unapply(x: Expr[Either[L, R]])(using Quotes): Option[Either[L, R]] = summon[Type[Either[L, R]]] match case '[Either[l, r]] => given Type[L] = Type.of[l].asInstanceOf[Type[L]] given Type[R] = Type.of[r].asInstanceOf[Type[R]] - given FromExpr[L] = lf.apply() - given FromExpr[R] = rf.apply() val result: Option[Either[L, R]] = x match case '{ $y: Left[L, R] } => y.value case '{ $y: Right[L, R] } => y.value case _ => None result - given leftFromExprFactory: [L: FromExprFactory as lf, R] => FromExprFactory[Left[L, R]]: + given leftFromExprFactory: [L: FromExprFactory, R] => FromExprFactory[Left[L, R]]: def apply()(using Type[Left[L, R]]): FromExpr[Left[L, R]] = new FromExpr[Left[L, R]]: def unapply(x: Expr[Left[L, R]])(using Quotes): Option[Left[L, R]] = summon[Type[Left[L, R]]] match case '[Left[l, r]] => given Type[L] = Type.of[l].asInstanceOf[Type[L]] given Type[R] = Type.of[r].asInstanceOf[Type[R]] - given FromExpr[L] = lf.apply() val result: Option[Left[L, R]] = x match case '{ Left[L, R](${Expr(y)}) } => Some(Left(y)) case _ => None result - given rightFromExprFactory: [L, R: FromExprFactory as rf] => FromExprFactory[Right[L, R]]: + given rightFromExprFactory: [L, R: FromExprFactory] => FromExprFactory[Right[L, R]]: def apply()(using Type[Right[L, R]]): FromExpr[Right[L, R]] = new FromExpr[Right[L, R]]: def unapply(x: Expr[Right[L, R]])(using Quotes): Option[Right[L, R]] = summon[Type[Right[L, R]]] match case '[Right[l, r]] => given Type[L] = Type.of[l].asInstanceOf[Type[L]] given Type[R] = Type.of[r].asInstanceOf[Type[R]] - given FromExpr[R] = rf.apply() val result: Option[Right[L, R]] = x match case '{ Right[L, R](${Expr(y)}) } => Some(Right(y)) case _ => None @@ -236,26 +224,23 @@ object FromExprFactory: // Tuple instances: same deferred-Type pattern as the containers above, mirroring the // hand-written Tuple1..22 instances in FromExpr (there is no hand-written TupleCons FromExpr). - given tuple1FromExprFactory: [T1: FromExprFactory as tf1] => FromExprFactory[Tuple1[T1]]: + given tuple1FromExprFactory: [T1: FromExprFactory] => FromExprFactory[Tuple1[T1]]: def apply()(using Type[Tuple1[T1]]): FromExpr[Tuple1[T1]] = new FromExpr[Tuple1[T1]]: def unapply(x: Expr[Tuple1[T1]])(using Quotes): Option[Tuple1[T1]] = summon[Type[Tuple1[T1]]] match case '[Tuple1[t1]] => given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] - given FromExpr[T1] = tf1.apply() val result: Option[Tuple1[T1]] = x match case '{ new Tuple1[T1](${Expr(y1)}) } => Some(Tuple1(y1)) case '{ Tuple1[T1](${Expr(y1)}) } => Some(Tuple1(y1)) case _ => None result - given tuple2FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2] => FromExprFactory[Tuple2[T1, T2]]: + given tuple2FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory] => FromExprFactory[Tuple2[T1, T2]]: def apply()(using Type[Tuple2[T1, T2]]): FromExpr[Tuple2[T1, T2]] = new FromExpr[Tuple2[T1, T2]]: def unapply(x: Expr[Tuple2[T1, T2]])(using Quotes): Option[Tuple2[T1, T2]] = summon[Type[Tuple2[T1, T2]]] match case '[Tuple2[t1, t2]] => given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() val result: Option[Tuple2[T1, T2]] = x match case '{ new Tuple2[T1, T2](${Expr(y1)}, ${Expr(y2)}) } => Some(Tuple2(y1, y2)) case '{ Tuple2[T1, T2](${Expr(y1)}, ${Expr(y2)}) } => Some(Tuple2(y1, y2)) @@ -263,23 +248,20 @@ object FromExprFactory: case _ => None result - given tuple3FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3] => FromExprFactory[Tuple3[T1, T2, T3]]: + given tuple3FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory] => FromExprFactory[Tuple3[T1, T2, T3]]: def apply()(using Type[Tuple3[T1, T2, T3]]): FromExpr[Tuple3[T1, T2, T3]] = new FromExpr[Tuple3[T1, T2, T3]]: def unapply(x: Expr[Tuple3[T1, T2, T3]])(using Quotes): Option[Tuple3[T1, T2, T3]] = summon[Type[Tuple3[T1, T2, T3]]] match case '[Tuple3[t1, t2, t3]] => given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() val result: Option[Tuple3[T1, T2, T3]] = x match case '{ new Tuple3[T1, T2, T3](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}) } => Some(Tuple3(y1, y2, y3)) case '{ Tuple3[T1, T2, T3](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}) } => Some(Tuple3(y1, y2, y3)) case _ => None result - given tuple4FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4] => FromExprFactory[Tuple4[T1, T2, T3, T4]]: + given tuple4FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory] => FromExprFactory[Tuple4[T1, T2, T3, T4]]: def apply()(using Type[Tuple4[T1, T2, T3, T4]]): FromExpr[Tuple4[T1, T2, T3, T4]] = new FromExpr[Tuple4[T1, T2, T3, T4]]: def unapply(x: Expr[Tuple4[T1, T2, T3, T4]])(using Quotes): Option[Tuple4[T1, T2, T3, T4]] = summon[Type[Tuple4[T1, T2, T3, T4]]] match case '[Tuple4[t1, t2, t3, t4]] => @@ -287,17 +269,13 @@ object FromExprFactory: given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() val result: Option[Tuple4[T1, T2, T3, T4]] = x match case '{ new Tuple4[T1, T2, T3, T4](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}) } => Some(Tuple4(y1, y2, y3, y4)) case '{ Tuple4[T1, T2, T3, T4](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}) } => Some(Tuple4(y1, y2, y3, y4)) case _ => None result - given tuple5FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5] => FromExprFactory[Tuple5[T1, T2, T3, T4, T5]]: + given tuple5FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory] => FromExprFactory[Tuple5[T1, T2, T3, T4, T5]]: def apply()(using Type[Tuple5[T1, T2, T3, T4, T5]]): FromExpr[Tuple5[T1, T2, T3, T4, T5]] = new FromExpr[Tuple5[T1, T2, T3, T4, T5]]: def unapply(x: Expr[Tuple5[T1, T2, T3, T4, T5]])(using Quotes): Option[Tuple5[T1, T2, T3, T4, T5]] = summon[Type[Tuple5[T1, T2, T3, T4, T5]]] match case '[Tuple5[t1, t2, t3, t4, t5]] => @@ -306,18 +284,13 @@ object FromExprFactory: given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() val result: Option[Tuple5[T1, T2, T3, T4, T5]] = x match case '{ new Tuple5[T1, T2, T3, T4, T5](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5)) case '{ Tuple5[T1, T2, T3, T4, T5](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5)) case _ => None result - given tuple6FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6] => FromExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]: + given tuple6FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory] => FromExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]: def apply()(using Type[Tuple6[T1, T2, T3, T4, T5, T6]]): FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]] = new FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: def unapply(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]])(using Quotes): Option[Tuple6[T1, T2, T3, T4, T5, T6]] = summon[Type[Tuple6[T1, T2, T3, T4, T5, T6]]] match case '[Tuple6[t1, t2, t3, t4, t5, t6]] => @@ -327,19 +300,13 @@ object FromExprFactory: given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() val result: Option[Tuple6[T1, T2, T3, T4, T5, T6]] = x match case '{ new Tuple6[T1, T2, T3, T4, T5, T6](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6)) case '{ Tuple6[T1, T2, T3, T4, T5, T6](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6)) case _ => None result - given tuple7FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7] => FromExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + given tuple7FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory] => FromExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: def apply()(using Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]): FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: def unapply(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]])(using Quotes): Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = summon[Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]] match case '[Tuple7[t1, t2, t3, t4, t5, t6, t7]] => @@ -350,20 +317,13 @@ object FromExprFactory: given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() val result: Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = x match case '{ new Tuple7[T1, T2, T3, T4, T5, T6, T7](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7)) case '{ Tuple7[T1, T2, T3, T4, T5, T6, T7](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7)) case _ => None result - given tuple8FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8] => FromExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + given tuple8FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory] => FromExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: def apply()(using Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]): FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: def unapply(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]])(using Quotes): Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = summon[Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]] match case '[Tuple8[t1, t2, t3, t4, t5, t6, t7, t8]] => @@ -375,21 +335,13 @@ object FromExprFactory: given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() val result: Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = x match case '{ new Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8)) case '{ Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8)) case _ => None result - given tuple9FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9] => FromExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + given tuple9FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory] => FromExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: def apply()(using Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]): FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: def unapply(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]])(using Quotes): Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = summon[Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]] match case '[Tuple9[t1, t2, t3, t4, t5, t6, t7, t8, t9]] => @@ -402,22 +354,13 @@ object FromExprFactory: given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() val result: Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = x match case '{ new Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9)) case '{ Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9)) case _ => None result - given tuple10FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10] => FromExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + given tuple10FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory] => FromExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: def apply()(using Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]): FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: def unapply(x: Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])(using Quotes): Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = summon[Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]] match case '[Tuple10[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10]] => @@ -431,23 +374,13 @@ object FromExprFactory: given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() val result: Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = x match case '{ new Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10)) case '{ Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10)) case _ => None result - given tuple11FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11] => FromExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + given tuple11FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory] => FromExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: def apply()(using Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]): FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: def unapply(x: Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]])(using Quotes): Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = summon[Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]] match case '[Tuple11[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11]] => @@ -462,24 +395,13 @@ object FromExprFactory: given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() val result: Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = x match case '{ new Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11)) case '{ Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11)) case _ => None result - given tuple12FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12] => FromExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + given tuple12FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory] => FromExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: def apply()(using Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]): FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: def unapply(x: Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]])(using Quotes): Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = summon[Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]] match case '[Tuple12[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12]] => @@ -495,25 +417,13 @@ object FromExprFactory: given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() val result: Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = x match case '{ new Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12)) case '{ Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12)) case _ => None result - given tuple13FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13] => FromExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + given tuple13FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory] => FromExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: def apply()(using Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]): FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: def unapply(x: Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]])(using Quotes): Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = summon[Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]] match case '[Tuple13[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13]] => @@ -530,26 +440,13 @@ object FromExprFactory: given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() val result: Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = x match case '{ new Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13)) case '{ Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13)) case _ => None result - given tuple14FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14] => FromExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + given tuple14FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory] => FromExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: def apply()(using Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]): FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: def unapply(x: Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]])(using Quotes): Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = summon[Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]] match case '[Tuple14[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14]] => @@ -567,27 +464,13 @@ object FromExprFactory: given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() val result: Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = x match case '{ new Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14)) case '{ Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14)) case _ => None result - given tuple15FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15] => FromExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + given tuple15FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory] => FromExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: def apply()(using Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]): FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: def unapply(x: Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]])(using Quotes): Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = summon[Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]] match case '[Tuple15[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15]] => @@ -606,28 +489,13 @@ object FromExprFactory: given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() val result: Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = x match case '{ new Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15)) case '{ Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15)) case _ => None result - given tuple16FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16] => FromExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + given tuple16FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory, T16: FromExprFactory] => FromExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: def apply()(using Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]): FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: def unapply(x: Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]])(using Quotes): Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = summon[Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]] match case '[Tuple16[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16]] => @@ -647,29 +515,13 @@ object FromExprFactory: given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() - given FromExpr[T16] = tf16.apply() val result: Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = x match case '{ new Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16)) case '{ Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16)) case _ => None result - given tuple17FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17] => FromExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + given tuple17FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory, T16: FromExprFactory, T17: FromExprFactory] => FromExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: def apply()(using Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]): FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: def unapply(x: Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]])(using Quotes): Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = summon[Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]] match case '[Tuple17[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17]] => @@ -690,30 +542,13 @@ object FromExprFactory: given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() - given FromExpr[T16] = tf16.apply() - given FromExpr[T17] = tf17.apply() val result: Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = x match case '{ new Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17)) case '{ Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17)) case _ => None result - given tuple18FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18] => FromExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + given tuple18FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory, T16: FromExprFactory, T17: FromExprFactory, T18: FromExprFactory] => FromExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: def apply()(using Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]): FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: def unapply(x: Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]])(using Quotes): Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = summon[Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]] match case '[Tuple18[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18]] => @@ -735,31 +570,13 @@ object FromExprFactory: given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() - given FromExpr[T16] = tf16.apply() - given FromExpr[T17] = tf17.apply() - given FromExpr[T18] = tf18.apply() val result: Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = x match case '{ new Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18)) case '{ Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18)) case _ => None result - given tuple19FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19] => FromExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + given tuple19FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory, T16: FromExprFactory, T17: FromExprFactory, T18: FromExprFactory, T19: FromExprFactory] => FromExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: def apply()(using Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]): FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: def unapply(x: Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]])(using Quotes): Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = summon[Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]] match case '[Tuple19[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19]] => @@ -782,32 +599,13 @@ object FromExprFactory: given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() - given FromExpr[T16] = tf16.apply() - given FromExpr[T17] = tf17.apply() - given FromExpr[T18] = tf18.apply() - given FromExpr[T19] = tf19.apply() val result: Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = x match case '{ new Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19)) case '{ Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19)) case _ => None result - given tuple20FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19, T20: FromExprFactory as tf20] => FromExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + given tuple20FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory, T16: FromExprFactory, T17: FromExprFactory, T18: FromExprFactory, T19: FromExprFactory, T20: FromExprFactory] => FromExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: def apply()(using Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]): FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: def unapply(x: Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]])(using Quotes): Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = summon[Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]] match case '[Tuple20[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20]] => @@ -831,33 +629,13 @@ object FromExprFactory: given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() - given FromExpr[T16] = tf16.apply() - given FromExpr[T17] = tf17.apply() - given FromExpr[T18] = tf18.apply() - given FromExpr[T19] = tf19.apply() - given FromExpr[T20] = tf20.apply() val result: Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = x match case '{ new Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20)) case '{ Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20)) case _ => None result - given tuple21FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19, T20: FromExprFactory as tf20, T21: FromExprFactory as tf21] => FromExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + given tuple21FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory, T16: FromExprFactory, T17: FromExprFactory, T18: FromExprFactory, T19: FromExprFactory, T20: FromExprFactory, T21: FromExprFactory] => FromExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: def apply()(using Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]): FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: def unapply(x: Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]])(using Quotes): Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = summon[Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]] match case '[Tuple21[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21]] => @@ -882,34 +660,13 @@ object FromExprFactory: given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() - given FromExpr[T16] = tf16.apply() - given FromExpr[T17] = tf17.apply() - given FromExpr[T18] = tf18.apply() - given FromExpr[T19] = tf19.apply() - given FromExpr[T20] = tf20.apply() - given FromExpr[T21] = tf21.apply() val result: Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = x match case '{ new Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21)) case '{ Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21)) case _ => None result - given tuple22FromExprFactory: [T1: FromExprFactory as tf1, T2: FromExprFactory as tf2, T3: FromExprFactory as tf3, T4: FromExprFactory as tf4, T5: FromExprFactory as tf5, T6: FromExprFactory as tf6, T7: FromExprFactory as tf7, T8: FromExprFactory as tf8, T9: FromExprFactory as tf9, T10: FromExprFactory as tf10, T11: FromExprFactory as tf11, T12: FromExprFactory as tf12, T13: FromExprFactory as tf13, T14: FromExprFactory as tf14, T15: FromExprFactory as tf15, T16: FromExprFactory as tf16, T17: FromExprFactory as tf17, T18: FromExprFactory as tf18, T19: FromExprFactory as tf19, T20: FromExprFactory as tf20, T21: FromExprFactory as tf21, T22: FromExprFactory as tf22] => FromExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + given tuple22FromExprFactory: [T1: FromExprFactory, T2: FromExprFactory, T3: FromExprFactory, T4: FromExprFactory, T5: FromExprFactory, T6: FromExprFactory, T7: FromExprFactory, T8: FromExprFactory, T9: FromExprFactory, T10: FromExprFactory, T11: FromExprFactory, T12: FromExprFactory, T13: FromExprFactory, T14: FromExprFactory, T15: FromExprFactory, T16: FromExprFactory, T17: FromExprFactory, T18: FromExprFactory, T19: FromExprFactory, T20: FromExprFactory, T21: FromExprFactory, T22: FromExprFactory] => FromExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: def apply()(using Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]): FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = new FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: def unapply(x: Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]])(using Quotes): Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = summon[Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]] match case '[Tuple22[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22]] => @@ -935,28 +692,6 @@ object FromExprFactory: given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] given Type[T22] = Type.of[t22].asInstanceOf[Type[T22]] - given FromExpr[T1] = tf1.apply() - given FromExpr[T2] = tf2.apply() - given FromExpr[T3] = tf3.apply() - given FromExpr[T4] = tf4.apply() - given FromExpr[T5] = tf5.apply() - given FromExpr[T6] = tf6.apply() - given FromExpr[T7] = tf7.apply() - given FromExpr[T8] = tf8.apply() - given FromExpr[T9] = tf9.apply() - given FromExpr[T10] = tf10.apply() - given FromExpr[T11] = tf11.apply() - given FromExpr[T12] = tf12.apply() - given FromExpr[T13] = tf13.apply() - given FromExpr[T14] = tf14.apply() - given FromExpr[T15] = tf15.apply() - given FromExpr[T16] = tf16.apply() - given FromExpr[T17] = tf17.apply() - given FromExpr[T18] = tf18.apply() - given FromExpr[T19] = tf19.apply() - given FromExpr[T20] = tf20.apply() - given FromExpr[T21] = tf21.apply() - given FromExpr[T22] = tf22.apply() val result: Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = x match case '{ new Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}, ${Expr(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22)) case '{ Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}, ${Expr(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22)) diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index 0f206736d942..13e4e1aaabb4 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -73,133 +73,118 @@ object ToExprFactory: case '[ClassTag[t]] => '{ ClassTag[t](${Expr(ct.runtimeClass.asInstanceOf[Class[t]])}) }.asInstanceOf[Expr[ClassTag[T]]] - given arrayToExprFactory: [T: {ToExprFactory as tf, ClassTag as ct}] => ToExprFactory[Array[T]]: + given arrayToExprFactory: [T: {ToExprFactory, ClassTag as ct}] => ToExprFactory[Array[T]]: def apply()(using Type[Array[T]]): ToExpr[Array[T]] = new ToExpr[Array[T]]: def apply(arr: Array[T])(using Quotes): Expr[Array[T]] = summon[Type[Array[T]]] match case '[Array[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val te = tf.apply() - val elemExprs = Expr.ofSeq(arr.toSeq.map(te.apply)) + val elemExprs = Expr.ofSeq(arr.toSeq.map(Expr(_))) '{ Array[T]($elemExprs*)(using ${Expr(ct)}) } - given seqToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Seq[T]]: + given seqToExprFactory: [T: ToExprFactory] => ToExprFactory[Seq[T]]: def apply()(using Type[Seq[T]]): ToExpr[Seq[T]] = new ToExpr[Seq[T]]: def apply(xs: Seq[T])(using Quotes): Expr[Seq[T]] = summon[Type[Seq[T]]] match case '[Seq[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val te = tf.apply() - Expr.ofSeq(xs.map(te.apply)) + Expr.ofSeq(xs.map(Expr(_))) - given listToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[List[T]]: + given listToExprFactory: [T: ToExprFactory] => ToExprFactory[List[T]]: def apply()(using Type[List[T]]): ToExpr[List[T]] = new ToExpr[List[T]]: def apply(xs: List[T])(using Quotes): Expr[List[T]] = summon[Type[List[T]]] match case '[List[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val te = tf.apply() - Expr.ofList(xs.map(te.apply)) + Expr.ofList(xs.map(Expr(_))) - given setToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Set[T]]: + given setToExprFactory: [T: ToExprFactory] => ToExprFactory[Set[T]]: def apply()(using Type[Set[T]]): ToExpr[Set[T]] = new ToExpr[Set[T]]: def apply(xs: Set[T])(using Quotes): Expr[Set[T]] = summon[Type[Set[T]]] match case '[Set[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val te = tf.apply() - val elemExprs = Expr.ofSeq(xs.toSeq.map(te.apply)) + val elemExprs = Expr.ofSeq(xs.toSeq.map(Expr(_))) '{ Set($elemExprs*) } - given mapToExprFactory: [T: ToExprFactory as tf, U: ToExprFactory as uf] => ToExprFactory[Map[T, U]]: + given mapToExprFactory: [T: ToExprFactory, U: ToExprFactory] => ToExprFactory[Map[T, U]]: def apply()(using Type[Map[T, U]]): ToExpr[Map[T, U]] = new ToExpr[Map[T, U]]: def apply(m: Map[T, U])(using Quotes): Expr[Map[T, U]] = summon[Type[Map[T, U]]] match case '[Map[t, u]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] given Type[U] = Type.of[u].asInstanceOf[Type[U]] - val te = tf.apply() - val ue = uf.apply() - val pairs = m.toSeq.map((k, v) => '{ (${te.apply(k)}, ${ue.apply(v)}) }) + val pairs = m.toSeq.map((k, v) => '{ (${Expr(k)}, ${Expr(v)}) }) '{ Map(${Expr.ofSeq(pairs)}*) } - given optionToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Option[T]]: + given optionToExprFactory: [T: ToExprFactory] => ToExprFactory[Option[T]]: def apply()(using Type[Option[T]]): ToExpr[Option[T]] = new ToExpr[Option[T]]: def apply(x: Option[T])(using Quotes): Expr[Option[T]] = summon[Type[Option[T]]] match case '[Option[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val te = tf.apply() x match - case Some(v) => '{ Some[T](${te.apply(v)}) } + case Some(v) => '{ Some[T](${Expr(v)}) } case None => '{ None } - given someToExprFactory: [T: ToExprFactory as tf] => ToExprFactory[Some[T]]: + given someToExprFactory: [T: ToExprFactory] => ToExprFactory[Some[T]]: def apply()(using Type[Some[T]]): ToExpr[Some[T]] = new ToExpr[Some[T]]: def apply(x: Some[T])(using Quotes): Expr[Some[T]] = summon[Type[Some[T]]] match case '[Some[t]] => given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val te = tf.apply() - '{ Some[T](${te.apply(x.get)}) } + '{ Some[T](${Expr(x.get)}) } - given eitherToExprFactory: [L: ToExprFactory as lf, R: ToExprFactory as rf] => ToExprFactory[Either[L, R]]: + given eitherToExprFactory: [L: ToExprFactory, R: ToExprFactory] => ToExprFactory[Either[L, R]]: def apply()(using Type[Either[L, R]]): ToExpr[Either[L, R]] = new ToExpr[Either[L, R]]: def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = summon[Type[Either[L, R]]] match case '[Either[l, r]] => given Type[L] = Type.of[l].asInstanceOf[Type[L]] given Type[R] = Type.of[r].asInstanceOf[Type[R]] - val le = lf.apply() - val re = rf.apply() x match - case scala.util.Left(v) => '{ Left[L, R](${le.apply(v)}) } - case scala.util.Right(v) => '{ Right[L, R](${re.apply(v)}) } + case scala.util.Left(v) => '{ Left[L, R](${Expr(v)}) } + case scala.util.Right(v) => '{ Right[L, R](${Expr(v)}) } - given leftToExprFactory: [L: ToExprFactory as lf, R] => ToExprFactory[Left[L, R]]: + given leftToExprFactory: [L: ToExprFactory, R] => ToExprFactory[Left[L, R]]: def apply()(using Type[Left[L, R]]): ToExpr[Left[L, R]] = new ToExpr[Left[L, R]]: def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = summon[Type[Left[L, R]]] match case '[Left[l, r]] => given Type[L] = Type.of[l].asInstanceOf[Type[L]] given Type[R] = Type.of[r].asInstanceOf[Type[R]] - val le = lf.apply() - '{ Left[L, R](${le.apply(x.value)}) } + '{ Left[L, R](${Expr(x.value)}) } - given rightToExprFactory: [L, R: ToExprFactory as rf] => ToExprFactory[Right[L, R]]: + given rightToExprFactory: [L, R: ToExprFactory] => ToExprFactory[Right[L, R]]: def apply()(using Type[Right[L, R]]): ToExpr[Right[L, R]] = new ToExpr[Right[L, R]]: def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = summon[Type[Right[L, R]]] match case '[Right[l, r]] => given Type[L] = Type.of[l].asInstanceOf[Type[L]] given Type[R] = Type.of[r].asInstanceOf[Type[R]] - val re = rf.apply() - '{ Right[L, R](${re.apply(x.value)}) } + '{ Right[L, R](${Expr(x.value)}) } // Tuple instances: same deferred-Type pattern as the containers above, mirroring the // hand-written Tuple1..22/TupleCons instances in ToExprFactory/FromExprFactory. - given tuple1ToExprFactory: [T1: ToExprFactory as tf1] => ToExprFactory[Tuple1[T1]]: + given tuple1ToExprFactory: [T1: ToExprFactory] => ToExprFactory[Tuple1[T1]]: def apply()(using Type[Tuple1[T1]]): ToExpr[Tuple1[T1]] = new ToExpr[Tuple1[T1]]: def apply(tup: Tuple1[T1])(using Quotes): Expr[Tuple1[T1]] = summon[Type[Tuple1[T1]]] match case '[Tuple1[t1]] => given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] - val e1 = tf1.apply().apply(tup._1) - '{ Tuple1(${e1}) } + '{ Tuple1(${Expr(tup._1)}) } - given tuple2ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2] => ToExprFactory[Tuple2[T1, T2]]: + + given tuple2ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory] => ToExprFactory[Tuple2[T1, T2]]: def apply()(using Type[Tuple2[T1, T2]]): ToExpr[Tuple2[T1, T2]] = new ToExpr[Tuple2[T1, T2]]: def apply(tup: Tuple2[T1, T2])(using Quotes): Expr[Tuple2[T1, T2]] = summon[Type[Tuple2[T1, T2]]] match case '[Tuple2[t1, t2]] => given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - '{ (${e1}, ${e2}) } + '{ (${Expr(tup._1)}, ${Expr(tup._2)}) } + - given tuple3ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3] => ToExprFactory[Tuple3[T1, T2, T3]]: + given tuple3ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory] => ToExprFactory[Tuple3[T1, T2, T3]]: def apply()(using Type[Tuple3[T1, T2, T3]]): ToExpr[Tuple3[T1, T2, T3]] = new ToExpr[Tuple3[T1, T2, T3]]: def apply(tup: Tuple3[T1, T2, T3])(using Quotes): Expr[Tuple3[T1, T2, T3]] = summon[Type[Tuple3[T1, T2, T3]]] match case '[Tuple3[t1, t2, t3]] => given Type[T1] = Type.of[t1].asInstanceOf[Type[T1]] given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - '{ (${e1}, ${e2}, ${e3}) } + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}) } + - given tuple4ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4] => ToExprFactory[Tuple4[T1, T2, T3, T4]]: + given tuple4ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory] => ToExprFactory[Tuple4[T1, T2, T3, T4]]: def apply()(using Type[Tuple4[T1, T2, T3, T4]]): ToExpr[Tuple4[T1, T2, T3, T4]] = new ToExpr[Tuple4[T1, T2, T3, T4]]: def apply(tup: Tuple4[T1, T2, T3, T4])(using Quotes): Expr[Tuple4[T1, T2, T3, T4]] = summon[Type[Tuple4[T1, T2, T3, T4]]] match case '[Tuple4[t1, t2, t3, t4]] => @@ -207,13 +192,10 @@ object ToExprFactory: given Type[T2] = Type.of[t2].asInstanceOf[Type[T2]] given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - '{ (${e1}, ${e2}, ${e3}, ${e4}) } + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}) } - given tuple5ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5] => ToExprFactory[Tuple5[T1, T2, T3, T4, T5]]: + + given tuple5ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory] => ToExprFactory[Tuple5[T1, T2, T3, T4, T5]]: def apply()(using Type[Tuple5[T1, T2, T3, T4, T5]]): ToExpr[Tuple5[T1, T2, T3, T4, T5]] = new ToExpr[Tuple5[T1, T2, T3, T4, T5]]: def apply(tup: Tuple5[T1, T2, T3, T4, T5])(using Quotes): Expr[Tuple5[T1, T2, T3, T4, T5]] = summon[Type[Tuple5[T1, T2, T3, T4, T5]]] match case '[Tuple5[t1, t2, t3, t4, t5]] => @@ -222,14 +204,10 @@ object ToExprFactory: given Type[T3] = Type.of[t3].asInstanceOf[Type[T3]] given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}) } - - given tuple6ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6] => ToExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}) } + + + given tuple6ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory] => ToExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]: def apply()(using Type[Tuple6[T1, T2, T3, T4, T5, T6]]): ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]] = new ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: def apply(tup: Tuple6[T1, T2, T3, T4, T5, T6])(using Quotes): Expr[Tuple6[T1, T2, T3, T4, T5, T6]] = summon[Type[Tuple6[T1, T2, T3, T4, T5, T6]]] match case '[Tuple6[t1, t2, t3, t4, t5, t6]] => @@ -239,15 +217,10 @@ object ToExprFactory: given Type[T4] = Type.of[t4].asInstanceOf[Type[T4]] given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}) } - - given tuple7ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7] => ToExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}) } + + + given tuple7ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory] => ToExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: def apply()(using Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]): ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = new ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: def apply(tup: Tuple7[T1, T2, T3, T4, T5, T6, T7])(using Quotes): Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = summon[Type[Tuple7[T1, T2, T3, T4, T5, T6, T7]]] match case '[Tuple7[t1, t2, t3, t4, t5, t6, t7]] => @@ -258,16 +231,10 @@ object ToExprFactory: given Type[T5] = Type.of[t5].asInstanceOf[Type[T5]] given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}) } - - given tuple8ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8] => ToExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}) } + + + given tuple8ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory] => ToExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: def apply()(using Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]): ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = new ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: def apply(tup: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8])(using Quotes): Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = summon[Type[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]] match case '[Tuple8[t1, t2, t3, t4, t5, t6, t7, t8]] => @@ -279,17 +246,10 @@ object ToExprFactory: given Type[T6] = Type.of[t6].asInstanceOf[Type[T6]] given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}) } - - given tuple9ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9] => ToExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}) } + + + given tuple9ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory] => ToExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: def apply()(using Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]): ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = new ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: def apply(tup: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9])(using Quotes): Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = summon[Type[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]] match case '[Tuple9[t1, t2, t3, t4, t5, t6, t7, t8, t9]] => @@ -302,18 +262,10 @@ object ToExprFactory: given Type[T7] = Type.of[t7].asInstanceOf[Type[T7]] given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}) } - - given tuple10ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10] => ToExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}) } + + + given tuple10ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory] => ToExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: def apply()(using Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]): ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = new ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: def apply(tup: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10])(using Quotes): Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = summon[Type[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]] match case '[Tuple10[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10]] => @@ -327,19 +279,10 @@ object ToExprFactory: given Type[T8] = Type.of[t8].asInstanceOf[Type[T8]] given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}) } - - given tuple11ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11] => ToExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}) } + + + given tuple11ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory] => ToExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: def apply()(using Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]): ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = new ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: def apply(tup: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11])(using Quotes): Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = summon[Type[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]] match case '[Tuple11[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11]] => @@ -354,20 +297,10 @@ object ToExprFactory: given Type[T9] = Type.of[t9].asInstanceOf[Type[T9]] given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}) } - - given tuple12ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12] => ToExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}) } + + + given tuple12ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory] => ToExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: def apply()(using Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]): ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = new ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: def apply(tup: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12])(using Quotes): Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = summon[Type[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]] match case '[Tuple12[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12]] => @@ -383,21 +316,10 @@ object ToExprFactory: given Type[T10] = Type.of[t10].asInstanceOf[Type[T10]] given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}) } - - given tuple13ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13] => ToExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}) } + + + given tuple13ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory] => ToExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: def apply()(using Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]): ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = new ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: def apply(tup: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13])(using Quotes): Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = summon[Type[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]] match case '[Tuple13[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13]] => @@ -414,22 +336,10 @@ object ToExprFactory: given Type[T11] = Type.of[t11].asInstanceOf[Type[T11]] given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}) } - - given tuple14ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14] => ToExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}) } + + + given tuple14ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory] => ToExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: def apply()(using Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]): ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = new ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: def apply(tup: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14])(using Quotes): Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = summon[Type[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]] match case '[Tuple14[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14]] => @@ -447,23 +357,10 @@ object ToExprFactory: given Type[T12] = Type.of[t12].asInstanceOf[Type[T12]] given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}) } - - given tuple15ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15] => ToExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}) } + + + given tuple15ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory] => ToExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: def apply()(using Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]): ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = new ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: def apply(tup: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15])(using Quotes): Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = summon[Type[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]] match case '[Tuple15[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15]] => @@ -482,24 +379,10 @@ object ToExprFactory: given Type[T13] = Type.of[t13].asInstanceOf[Type[T13]] given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}) } - - given tuple16ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16] => ToExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}) } + + + given tuple16ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory, T16: ToExprFactory] => ToExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: def apply()(using Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]): ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = new ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: def apply(tup: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16])(using Quotes): Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = summon[Type[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]] match case '[Tuple16[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16]] => @@ -519,25 +402,10 @@ object ToExprFactory: given Type[T14] = Type.of[t14].asInstanceOf[Type[T14]] given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - val e16 = tf16.apply().apply(tup._16) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}) } - - given tuple17ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17] => ToExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}) } + + + given tuple17ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory, T16: ToExprFactory, T17: ToExprFactory] => ToExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: def apply()(using Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]): ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = new ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: def apply(tup: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17])(using Quotes): Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = summon[Type[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]] match case '[Tuple17[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17]] => @@ -558,26 +426,10 @@ object ToExprFactory: given Type[T15] = Type.of[t15].asInstanceOf[Type[T15]] given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - val e16 = tf16.apply().apply(tup._16) - val e17 = tf17.apply().apply(tup._17) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}) } - - given tuple18ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18] => ToExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}, ${Expr(tup._17)}) } + + + given tuple18ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory, T16: ToExprFactory, T17: ToExprFactory, T18: ToExprFactory] => ToExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: def apply()(using Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]): ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = new ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: def apply(tup: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18])(using Quotes): Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = summon[Type[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]] match case '[Tuple18[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18]] => @@ -599,27 +451,10 @@ object ToExprFactory: given Type[T16] = Type.of[t16].asInstanceOf[Type[T16]] given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - val e16 = tf16.apply().apply(tup._16) - val e17 = tf17.apply().apply(tup._17) - val e18 = tf18.apply().apply(tup._18) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}) } - - given tuple19ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19] => ToExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}, ${Expr(tup._17)}, ${Expr(tup._18)}) } + + + given tuple19ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory, T16: ToExprFactory, T17: ToExprFactory, T18: ToExprFactory, T19: ToExprFactory] => ToExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: def apply()(using Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]): ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = new ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: def apply(tup: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19])(using Quotes): Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = summon[Type[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]] match case '[Tuple19[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19]] => @@ -642,28 +477,10 @@ object ToExprFactory: given Type[T17] = Type.of[t17].asInstanceOf[Type[T17]] given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - val e16 = tf16.apply().apply(tup._16) - val e17 = tf17.apply().apply(tup._17) - val e18 = tf18.apply().apply(tup._18) - val e19 = tf19.apply().apply(tup._19) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}) } - - given tuple20ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19, T20: ToExprFactory as tf20] => ToExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}, ${Expr(tup._17)}, ${Expr(tup._18)}, ${Expr(tup._19)}) } + + + given tuple20ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory, T16: ToExprFactory, T17: ToExprFactory, T18: ToExprFactory, T19: ToExprFactory, T20: ToExprFactory] => ToExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: def apply()(using Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]): ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = new ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: def apply(tup: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20])(using Quotes): Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = summon[Type[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]] match case '[Tuple20[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20]] => @@ -687,29 +504,10 @@ object ToExprFactory: given Type[T18] = Type.of[t18].asInstanceOf[Type[T18]] given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - val e16 = tf16.apply().apply(tup._16) - val e17 = tf17.apply().apply(tup._17) - val e18 = tf18.apply().apply(tup._18) - val e19 = tf19.apply().apply(tup._19) - val e20 = tf20.apply().apply(tup._20) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}, ${e20}) } - - given tuple21ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19, T20: ToExprFactory as tf20, T21: ToExprFactory as tf21] => ToExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}, ${Expr(tup._17)}, ${Expr(tup._18)}, ${Expr(tup._19)}, ${Expr(tup._20)}) } + + + given tuple21ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory, T16: ToExprFactory, T17: ToExprFactory, T18: ToExprFactory, T19: ToExprFactory, T20: ToExprFactory, T21: ToExprFactory] => ToExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: def apply()(using Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]): ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = new ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: def apply(tup: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21])(using Quotes): Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = summon[Type[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]] match case '[Tuple21[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21]] => @@ -734,30 +532,10 @@ object ToExprFactory: given Type[T19] = Type.of[t19].asInstanceOf[Type[T19]] given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - val e16 = tf16.apply().apply(tup._16) - val e17 = tf17.apply().apply(tup._17) - val e18 = tf18.apply().apply(tup._18) - val e19 = tf19.apply().apply(tup._19) - val e20 = tf20.apply().apply(tup._20) - val e21 = tf21.apply().apply(tup._21) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}, ${e20}, ${e21}) } - - given tuple22ToExprFactory: [T1: ToExprFactory as tf1, T2: ToExprFactory as tf2, T3: ToExprFactory as tf3, T4: ToExprFactory as tf4, T5: ToExprFactory as tf5, T6: ToExprFactory as tf6, T7: ToExprFactory as tf7, T8: ToExprFactory as tf8, T9: ToExprFactory as tf9, T10: ToExprFactory as tf10, T11: ToExprFactory as tf11, T12: ToExprFactory as tf12, T13: ToExprFactory as tf13, T14: ToExprFactory as tf14, T15: ToExprFactory as tf15, T16: ToExprFactory as tf16, T17: ToExprFactory as tf17, T18: ToExprFactory as tf18, T19: ToExprFactory as tf19, T20: ToExprFactory as tf20, T21: ToExprFactory as tf21, T22: ToExprFactory as tf22] => ToExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}, ${Expr(tup._17)}, ${Expr(tup._18)}, ${Expr(tup._19)}, ${Expr(tup._20)}, ${Expr(tup._21)}) } + + + given tuple22ToExprFactory: [T1: ToExprFactory, T2: ToExprFactory, T3: ToExprFactory, T4: ToExprFactory, T5: ToExprFactory, T6: ToExprFactory, T7: ToExprFactory, T8: ToExprFactory, T9: ToExprFactory, T10: ToExprFactory, T11: ToExprFactory, T12: ToExprFactory, T13: ToExprFactory, T14: ToExprFactory, T15: ToExprFactory, T16: ToExprFactory, T17: ToExprFactory, T18: ToExprFactory, T19: ToExprFactory, T20: ToExprFactory, T21: ToExprFactory, T22: ToExprFactory] => ToExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: def apply()(using Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]): ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = new ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: def apply(tup: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22])(using Quotes): Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = summon[Type[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]] match case '[Tuple22[t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22]] => @@ -783,36 +561,15 @@ object ToExprFactory: given Type[T20] = Type.of[t20].asInstanceOf[Type[T20]] given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] given Type[T22] = Type.of[t22].asInstanceOf[Type[T22]] - val e1 = tf1.apply().apply(tup._1) - val e2 = tf2.apply().apply(tup._2) - val e3 = tf3.apply().apply(tup._3) - val e4 = tf4.apply().apply(tup._4) - val e5 = tf5.apply().apply(tup._5) - val e6 = tf6.apply().apply(tup._6) - val e7 = tf7.apply().apply(tup._7) - val e8 = tf8.apply().apply(tup._8) - val e9 = tf9.apply().apply(tup._9) - val e10 = tf10.apply().apply(tup._10) - val e11 = tf11.apply().apply(tup._11) - val e12 = tf12.apply().apply(tup._12) - val e13 = tf13.apply().apply(tup._13) - val e14 = tf14.apply().apply(tup._14) - val e15 = tf15.apply().apply(tup._15) - val e16 = tf16.apply().apply(tup._16) - val e17 = tf17.apply().apply(tup._17) - val e18 = tf18.apply().apply(tup._18) - val e19 = tf19.apply().apply(tup._19) - val e20 = tf20.apply().apply(tup._20) - val e21 = tf21.apply().apply(tup._21) - val e22 = tf22.apply().apply(tup._22) - '{ (${e1}, ${e2}, ${e3}, ${e4}, ${e5}, ${e6}, ${e7}, ${e8}, ${e9}, ${e10}, ${e11}, ${e12}, ${e13}, ${e14}, ${e15}, ${e16}, ${e17}, ${e18}, ${e19}, ${e20}, ${e21}, ${e22}) } - - given tupleConsToExprFactory: [H: ToExprFactory as hf, T <: Tuple: ToExprFactory as tf] => ToExprFactory[H *: T]: + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}, ${Expr(tup._17)}, ${Expr(tup._18)}, ${Expr(tup._19)}, ${Expr(tup._20)}, ${Expr(tup._21)}, ${Expr(tup._22)}) } + + + given tupleConsToExprFactory: [H: ToExprFactory, T <: Tuple: ToExprFactory] => ToExprFactory[H *: T]: def apply()(using Type[H *: T]): ToExpr[H *: T] = new ToExpr[H *: T]: def apply(tup: H *: T)(using Quotes): Expr[H *: T] = summon[Type[H *: T]] match case '[h *: t] => given Type[H] = Type.of[h].asInstanceOf[Type[H]] given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val head = hf.apply().apply(tup.head) - val tail = tf.apply().apply(tup.tail) + val head = Expr(tup.head) + val tail = Expr(tup.tail) '{ $head *: $tail } From a22884e9ec557133b6cfec7bb318a9c7fd9d5849 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Wed, 15 Jul 2026 17:17:26 +0200 Subject: [PATCH 13/17] Name the FromExprFactory/ToExprFactory proxy params; proxy Tuple1..22/TupleCons too MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Give the proxy givens in FromExpr.scala/ToExpr.scala a named factory parameter (e.g. `(factory: FromExprFactory[Option[T]]) =>`) instead of `summon[...]` inline, matching the existing fromFactory/fromToExpr/fromFromExpr bridge style. Also converts the hand-written Tuple1FromExpr..Tuple22FromExpr and Tuple1ToExpr..Tuple22ToExpr/TupleConsToExpr givens to proxy to the tupleNFromExprFactory/tupleNToExprFactory/tupleConsToExprFactory instances added earlier, instead of duplicating their pattern-matching logic — the same treatment already given to Seq/List/Set/Map/Option/Some/Either/Left/Right. Co-Authored-By: Claude Sonnet 5 --- library/src/scala/quoted/FromExpr.scala | 345 ++++++------------------ library/src/scala/quoted/ToExpr.scala | 266 +++++++----------- 2 files changed, 175 insertions(+), 436 deletions(-) diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index a6f2cbdd6949..d768c6eb43e8 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -115,8 +115,8 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{None}` into `Some(None)` * - Otherwise returns `None` */ - given OptionFromExpr: [T: {Type, FromExpr}] => FromExpr[Option[T]]: - def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] = summon[FromExprFactory[Option[T]]].apply().unapply(x) + given OptionFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Option[T]]) => FromExpr[Option[T]]: + def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[None]` * - Transform `'{None}` into `Some(None)` @@ -133,8 +133,8 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{Some(x)}` into `Some(Some(x))` if `x` can be transformed using `FromExpr[T]` * - Otherwise returns `None` */ - given SomeFromExpr: [T: {Type, FromExpr}] => FromExpr[Some[T]]: - def unapply(x: Expr[Some[T]])(using Quotes): Option[Some[T]] = summon[FromExprFactory[Some[T]]].apply().unapply(x) + given SomeFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Some[T]]) => FromExpr[Some[T]]: + def unapply(x: Expr[Some[T]])(using Quotes): Option[Some[T]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[StringContext]` * - Transform `'{StringContext(args*)}` into `Some(StringContext(args*))` if `args` is explicit and each one is liftable @@ -159,278 +159,101 @@ object FromExpr extends LowPriorityFromExpr: } } - /** Default implementation of `FromExpr[Tuple1[...]]` - * - Transform `'{Tuple1(x1)}` into `Some(Tuple1(x1))` if `x1` can be transformed using `FromExpr[T]` - * - Otherwise returns `None` - */ - given Tuple1FromExpr[T1](using Type[T1], FromExpr[T1]): FromExpr[Tuple1[T1]] with { - def unapply(x: Expr[Tuple1[T1]])(using Quotes) = x match { - case '{ new Tuple1[T1](${Expr(y)}) } => Some(Tuple1(y)) - case '{ Tuple1[T1](${Expr(y)}) } => Some(Tuple1(y)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple1[T1]]`. Proxies to `FromExprFactory.tuple1FromExprFactory`. */ + given Tuple1FromExpr: [T1: {Type, FromExpr}] => (factory: FromExprFactory[Tuple1[T1]]) => FromExpr[Tuple1[T1]]: + def unapply(x: Expr[Tuple1[T1]])(using Quotes): Option[Tuple1[T1]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple2[...]]` - * - Transform `'{Tuple2(x1, x2)}` into `Some(Tuple2(x1, x2))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple2FromExpr[T1, T2](using Type[T1], Type[T2], FromExpr[T1], FromExpr[T2]): FromExpr[Tuple2[T1, T2]] with { - def unapply(x: Expr[Tuple2[T1, T2]])(using Quotes) = x match { - case '{ new Tuple2[T1, T2](${Expr(y1)}, ${Expr(y2)}) } => Some(Tuple2(y1, y2)) - case '{ Tuple2[T1, T2](${Expr(y1)}, ${Expr(y2)}) } => Some(Tuple2(y1, y2)) - case '{ (${Expr(y1)}: T1) -> (${Expr(y2)}: T2) } => Some(Tuple2(y1, y2)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple2[T1, T2]]`. Proxies to `FromExprFactory.tuple2FromExprFactory`. */ + given Tuple2FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}] => (factory: FromExprFactory[Tuple2[T1, T2]]) => FromExpr[Tuple2[T1, T2]]: + def unapply(x: Expr[Tuple2[T1, T2]])(using Quotes): Option[Tuple2[T1, T2]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple3[...]]` - * - Transform `'{Tuple3(x1, x2, x3)}` into `Some(Tuple3(x1, x2, x3))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple3FromExpr[T1, T2, T3](using Type[T1], Type[T2], Type[T3], FromExpr[T1], FromExpr[T2], FromExpr[T3]): FromExpr[Tuple3[T1, T2, T3]] with { - def unapply(x: Expr[Tuple3[T1, T2, T3]])(using Quotes) = x match { - case '{ new Tuple3[T1, T2, T3](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}) } => Some(Tuple3(y1, y2, y3)) - case '{ Tuple3[T1, T2, T3](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}) } => Some(Tuple3(y1, y2, y3)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple3[T1, T2, T3]]`. Proxies to `FromExprFactory.tuple3FromExprFactory`. */ + given Tuple3FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}] => (factory: FromExprFactory[Tuple3[T1, T2, T3]]) => FromExpr[Tuple3[T1, T2, T3]]: + def unapply(x: Expr[Tuple3[T1, T2, T3]])(using Quotes): Option[Tuple3[T1, T2, T3]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple4[...]]` - * - Transform `'{Tuple4(x1, ..., x4)}` into `Some(Tuple4(x1, ..., x4))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple4FromExpr[T1, T2, T3, T4](using Type[T1], Type[T2], Type[T3], Type[T4], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4]): FromExpr[Tuple4[T1, T2, T3, T4]] with { - def unapply(x: Expr[Tuple4[T1, T2, T3, T4]])(using Quotes) = x match { - case '{ new Tuple4[T1, T2, T3, T4](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}) } => Some(Tuple4(y1, y2, y3, y4)) - case '{ Tuple4[T1, T2, T3, T4](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}) } => Some(Tuple4(y1, y2, y3, y4)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple4[T1, T2, T3, T4]]`. Proxies to `FromExprFactory.tuple4FromExprFactory`. */ + given Tuple4FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}] => (factory: FromExprFactory[Tuple4[T1, T2, T3, T4]]) => FromExpr[Tuple4[T1, T2, T3, T4]]: + def unapply(x: Expr[Tuple4[T1, T2, T3, T4]])(using Quotes): Option[Tuple4[T1, T2, T3, T4]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple5[...]]` - * - Transform `'{Tuple5(x1, ..., x5)}` into `Some(Tuple5(x1, ..., x5))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple5FromExpr[T1, T2, T3, T4, T5](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5]): FromExpr[Tuple5[T1, T2, T3, T4, T5]] with { - def unapply(x: Expr[Tuple5[T1, T2, T3, T4, T5]])(using Quotes) = x match { - case '{ new Tuple5[T1, T2, T3, T4, T5](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5)) - case '{ Tuple5[T1, T2, T3, T4, T5](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}) } => Some(Tuple5(y1, y2, y3, y4, y5)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple5[T1, T2, T3, T4, T5]]`. Proxies to `FromExprFactory.tuple5FromExprFactory`. */ + given Tuple5FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}] => (factory: FromExprFactory[Tuple5[T1, T2, T3, T4, T5]]) => FromExpr[Tuple5[T1, T2, T3, T4, T5]]: + def unapply(x: Expr[Tuple5[T1, T2, T3, T4, T5]])(using Quotes): Option[Tuple5[T1, T2, T3, T4, T5]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple6[...]]` - * - Transform `'{Tuple6(x1, ..., x6)}` into `Some(Tuple6(x1, ..., x6))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple6FromExpr[T1, T2, T3, T4, T5, T6](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6]): FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]] with { - def unapply(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]])(using Quotes) = x match { - case '{ new Tuple6[T1, T2, T3, T4, T5, T6](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6)) - case '{ Tuple6[T1, T2, T3, T4, T5, T6](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}) } => Some(Tuple6(y1, y2, y3, y4, y5, y6)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]]`. Proxies to `FromExprFactory.tuple6FromExprFactory`. */ + given Tuple6FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}] => (factory: FromExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]) => FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: + def unapply(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]])(using Quotes): Option[Tuple6[T1, T2, T3, T4, T5, T6]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple7[...]]` - * - Transform `'{Tuple7(x1, ..., x7)}` into `Some(Tuple7(x1, ..., x7))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple7FromExpr[T1, T2, T3, T4, T5, T6, T7](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7]): FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] with { - def unapply(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]])(using Quotes) = x match { - case '{ new Tuple7[T1, T2, T3, T4, T5, T6, T7](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7)) - case '{ Tuple7[T1, T2, T3, T4, T5, T6, T7](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}) } => Some(Tuple7(y1, y2, y3, y4, y5, y6, y7)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]`. Proxies to `FromExprFactory.tuple7FromExprFactory`. */ + given Tuple7FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}] => (factory: FromExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]) => FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def unapply(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]])(using Quotes): Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple8[...]]` - * - Transform `'{Tuple8(x1, ..., x8)}` into `Some(Tuple8(x1, ..., x8))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple8FromExpr[T1, T2, T3, T4, T5, T6, T7, T8](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8]): FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] with { - def unapply(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]])(using Quotes) = x match { - case '{ new Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8)) - case '{ Tuple8[T1, T2, T3, T4, T5, T6, T7, T8](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}) } => Some(Tuple8(y1, y2, y3, y4, y5, y6, y7, y8)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]`. Proxies to `FromExprFactory.tuple8FromExprFactory`. */ + given Tuple8FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}] => (factory: FromExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]) => FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def unapply(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]])(using Quotes): Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple9[...]]` - * - Transform `'{Tuple9(x1, ..., x9)}` into `Some(Tuple9(x1, ..., x9))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple9FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9]): FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] with { - def unapply(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]])(using Quotes) = x match { - case '{ new Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9)) - case '{ Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}) } => Some(Tuple9(y1, y2, y3, y4, y5, y6, y7, y8, y9)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]`. Proxies to `FromExprFactory.tuple9FromExprFactory`. */ + given Tuple9FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}] => (factory: FromExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]) => FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def unapply(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]])(using Quotes): Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple10[...]]` - * - Transform `'{Tuple0(x1, ..., x10)}` into `Some(Tuple0(x1, ..., x10))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple10FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10]): FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] with { - def unapply(x: Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])(using Quotes) = x match { - case '{ new Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10)) - case '{ Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}) } => Some(Tuple10(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]`. Proxies to `FromExprFactory.tuple10FromExprFactory`. */ + given Tuple10FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}] => (factory: FromExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]) => FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def unapply(x: Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])(using Quotes): Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple11[...]]` - * - Transform `'{Tuple1(x1, ..., x11)}` into `Some(Tuple1(x1, ..., x11))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple11FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11]): FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] with { - def unapply(x: Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]])(using Quotes) = x match { - case '{ new Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11)) - case '{ Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}) } => Some(Tuple11(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]`. Proxies to `FromExprFactory.tuple11FromExprFactory`. */ + given Tuple11FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}] => (factory: FromExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]) => FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def unapply(x: Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]])(using Quotes): Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple12[...]]` - * - Transform `'{Tuple2(x1, ..., x12)}` into `Some(Tuple2(x1, ..., x12))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple12FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12]): FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] with { - def unapply(x: Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]])(using Quotes) = x match { - case '{ new Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12)) - case '{ Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}) } => Some(Tuple12(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]`. Proxies to `FromExprFactory.tuple12FromExprFactory`. */ + given Tuple12FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}] => (factory: FromExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]) => FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def unapply(x: Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]])(using Quotes): Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple13[...]]` - * - Transform `'{Tuple3(x1, ..., x13)}` into `Some(Tuple3(x1, ..., x13))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple13FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13]): FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] with { - def unapply(x: Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]])(using Quotes) = x match { - case '{ new Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13)) - case '{ Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}) } => Some(Tuple13(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]`. Proxies to `FromExprFactory.tuple13FromExprFactory`. */ + given Tuple13FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}] => (factory: FromExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]) => FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def unapply(x: Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]])(using Quotes): Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple14[...]]` - * - Transform `'{Tuple4(x1, ..., x14)}` into `Some(Tuple4(x1, ..., x14))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple14FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14]): FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] with { - def unapply(x: Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]])(using Quotes) = x match { - case '{ new Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14)) - case '{ Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}) } => Some(Tuple14(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]`. Proxies to `FromExprFactory.tuple14FromExprFactory`. */ + given Tuple14FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}] => (factory: FromExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]) => FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def unapply(x: Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]])(using Quotes): Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple15[...]]` - * - Transform `'{Tuple5(x1, ..., x15)}` into `Some(Tuple5(x1, ..., x15))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple15FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15]): FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] with { - def unapply(x: Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]])(using Quotes) = x match { - case '{ new Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15)) - case '{ Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}) } => Some(Tuple15(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]`. Proxies to `FromExprFactory.tuple15FromExprFactory`. */ + given Tuple15FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}] => (factory: FromExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]) => FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def unapply(x: Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]])(using Quotes): Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple16[...]]` - * - Transform `'{Tuple6(x1, ..., x16)}` into `Some(Tuple6(x1, ..., x16))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple16FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16]): FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] with { - def unapply(x: Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]])(using Quotes) = x match { - case '{ new Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16)) - case '{ Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}) } => Some(Tuple16(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]`. Proxies to `FromExprFactory.tuple16FromExprFactory`. */ + given Tuple16FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}] => (factory: FromExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]) => FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def unapply(x: Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]])(using Quotes): Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple17[...]]` - * - Transform `'{Tuple7(x1, ..., x17)}` into `Some(Tuple7(x1, ..., x17))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple17FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17]): FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] with { - def unapply(x: Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]])(using Quotes) = x match { - case '{ new Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17)) - case '{ Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}) } => Some(Tuple17(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]`. Proxies to `FromExprFactory.tuple17FromExprFactory`. */ + given Tuple17FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}] => (factory: FromExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]) => FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def unapply(x: Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]])(using Quotes): Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple18[...]]` - * - Transform `'{Tuple8(x1, ..., x18)}` into `Some(Tuple8(x1, ..., x18))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple18FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18]): FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] with { - def unapply(x: Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]])(using Quotes) = x match { - case '{ new Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18)) - case '{ Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}) } => Some(Tuple18(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]`. Proxies to `FromExprFactory.tuple18FromExprFactory`. */ + given Tuple18FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}] => (factory: FromExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]) => FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def unapply(x: Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]])(using Quotes): Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple19[...]]` - * - Transform `'{Tuple9(x1, ..., x19)}` into `Some(Tuple9(x1, ..., x19))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple19FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19]): FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] with { - def unapply(x: Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]])(using Quotes) = x match { - case '{ new Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19)) - case '{ Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}) } => Some(Tuple19(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]`. Proxies to `FromExprFactory.tuple19FromExprFactory`. */ + given Tuple19FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}] => (factory: FromExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]) => FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def unapply(x: Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]])(using Quotes): Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple20[...]]` - * - Transform `'{Tuple0(x1, ..., x20)}` into `Some(Tuple0(x1, ..., x20))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple20FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20]): FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] with { - def unapply(x: Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]])(using Quotes) = x match { - case '{ new Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20)) - case '{ Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}) } => Some(Tuple20(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]`. Proxies to `FromExprFactory.tuple20FromExprFactory`. */ + given Tuple20FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}, T20: {Type, FromExpr}] => (factory: FromExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]) => FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def unapply(x: Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]])(using Quotes): Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple21[...]]` - * - Transform `'{Tuple1(x1, ..., x21)}` into `Some(Tuple1(x1, ..., x21))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple21FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20], FromExpr[T21]): FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] with { - def unapply(x: Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]])(using Quotes) = x match { - case '{ new Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21)) - case '{ Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}) } => Some(Tuple21(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]`. Proxies to `FromExprFactory.tuple21FromExprFactory`. */ + given Tuple21FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}, T20: {Type, FromExpr}, T21: {Type, FromExpr}] => (factory: FromExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]) => FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def unapply(x: Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]])(using Quotes): Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = factory.apply().unapply(x) - /** Default implementation of `FromExpr[Tuple22[...]]` - * - Transform `'{Tuple2(x1, ..., x22)}` into `Some(Tuple2(x1, ..., x22))` if all `xi` can be transformed using `FromExpr[Ti]` - * - Otherwise returns `None` - */ - given Tuple22FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], Type[T22], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20], FromExpr[T21], FromExpr[T22]): FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] with { - def unapply(x: Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]])(using Quotes) = x match { - case '{ new Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}, ${Expr(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22)) - case '{ Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](${Expr(y1)}, ${Expr(y2)}, ${Expr(y3)}, ${Expr(y4)}, ${Expr(y5)}, ${Expr(y6)}, ${Expr(y7)}, ${Expr(y8)}, ${Expr(y9)}, ${Expr(y10)}, ${Expr(y11)}, ${Expr(y12)}, ${Expr(y13)}, ${Expr(y14)}, ${Expr(y15)}, ${Expr(y16)}, ${Expr(y17)}, ${Expr(y18)}, ${Expr(y19)}, ${Expr(y20)}, ${Expr(y21)}, ${Expr(y22)}) } => Some(Tuple22(y1, y2, y3, y4, y5, y6, y7, y8, y9, y10, y11, y12, y13, y14, y15, y16, y17, y18, y19, y20, y21, y22)) - case _ => None - } - } + /** Default implementation of `FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]`. Proxies to `FromExprFactory.tuple22FromExprFactory`. */ + given Tuple22FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}, T20: {Type, FromExpr}, T21: {Type, FromExpr}, T22: {Type, FromExpr}] => (factory: FromExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]) => FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def unapply(x: Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]])(using Quotes): Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[Seq]` * - Transform `'{Seq(x1, ..., xn)}` into `Some(Seq(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform sequences that come out of varargs * - Otherwise returns `None` */ - given SeqFromExpr: [T: {Type, FromExpr}] => FromExpr[Seq[T]]: - def unapply(x: Expr[Seq[T]])(using Quotes): Option[Seq[T]] = summon[FromExprFactory[Seq[T]]].apply().unapply(x) + given SeqFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Seq[T]]) => FromExpr[Seq[T]]: + def unapply(x: Expr[Seq[T]])(using Quotes): Option[Seq[T]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[Nil]` * - Transform `'{Nil}` into `Some(Nil)` @@ -449,43 +272,43 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{Nil}` into `Some(Nil)` * - Otherwise returns `None` */ - given ListFromExpr: [T: {Type, FromExpr}] => FromExpr[List[T]]: - def unapply(x: Expr[List[T]])(using Quotes): Option[List[T]] = summon[FromExprFactory[List[T]]].apply().unapply(x) + given ListFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[List[T]]) => FromExpr[List[T]]: + def unapply(x: Expr[List[T]])(using Quotes): Option[List[T]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[Set]` * - Transform `'{Set(x1, ..., xn)}` into `Some(Set(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform `'{Set.empty}` into `Some(Set())` * - Otherwise returns `None` */ - given SetFromExpr: [T: {Type, FromExpr}] => FromExpr[Set[T]]: - def unapply(x: Expr[Set[T]])(using Quotes): Option[Set[T]] = summon[FromExprFactory[Set[T]]].apply().unapply(x) + given SetFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Set[T]]) => FromExpr[Set[T]]: + def unapply(x: Expr[Set[T]])(using Quotes): Option[Set[T]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[Map]` * - Transform `'{Map(x1, ..., xn)}` into `Some(Map(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform `'{Map.empty}` into `Some(Map())` * - Otherwise returns `None` */ - given MapFromExpr: [T: {Type, FromExpr}, U: {Type, FromExpr}] => FromExpr[Map[T, U]]: - def unapply(x: Expr[Map[T, U]])(using Quotes): Option[Map[T, U]] = summon[FromExprFactory[Map[T, U]]].apply().unapply(x) + given MapFromExpr: [T: {Type, FromExpr}, U: {Type, FromExpr}] => (factory: FromExprFactory[Map[T, U]]) => FromExpr[Map[T, U]]: + def unapply(x: Expr[Map[T, U]])(using Quotes): Option[Map[T, U]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[Either]` * - Transform `'{Left(x)}` into `Some(Left(x))` if `x` can be transformed using `FromExpr[L]` * - Transform `'{Right(x)}` into `Some(Right(x))` if `x` can be transformed using `FromExpr[R]` * - Otherwise returns `None` */ - given EitherFromExpr: [L: {Type, FromExpr}, R: {Type, FromExpr}] => FromExpr[Either[L, R]]: - def unapply(x: Expr[Either[L, R]])(using Quotes): Option[Either[L, R]] = summon[FromExprFactory[Either[L, R]]].apply().unapply(x) + given EitherFromExpr: [L: {Type, FromExpr}, R: {Type, FromExpr}] => (factory: FromExprFactory[Either[L, R]]) => FromExpr[Either[L, R]]: + def unapply(x: Expr[Either[L, R]])(using Quotes): Option[Either[L, R]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[Left]` * - Transform `'{Left(x)}` into `Some(Left(x))` if `x` can be transformed using `FromExpr[L]` * - Otherwise returns `None` */ - given LeftFromExpr: [L: {Type, FromExpr}, R: Type] => FromExpr[Left[L, R]]: - def unapply(x: Expr[Left[L, R]])(using Quotes): Option[Left[L, R]] = summon[FromExprFactory[Left[L, R]]].apply().unapply(x) + given LeftFromExpr: [L: {Type, FromExpr}, R: Type] => (factory: FromExprFactory[Left[L, R]]) => FromExpr[Left[L, R]]: + def unapply(x: Expr[Left[L, R]])(using Quotes): Option[Left[L, R]] = factory.apply().unapply(x) /** Default implementation of `FromExpr[Right]` * - Transform `'{Right(x)}` into `Some(Right(x))` if `x` can be transformed using `FromExpr[R]` * - Otherwise returns `None` */ - given RightFromExpr: [L: Type, R: {Type, FromExpr}] => FromExpr[Right[L, R]]: - def unapply(x: Expr[Right[L, R]])(using Quotes): Option[Right[L, R]] = summon[FromExprFactory[Right[L, R]]].apply().unapply(x) + given RightFromExpr: [L: Type, R: {Type, FromExpr}] => (factory: FromExprFactory[Right[L, R]]) => FromExpr[Right[L, R]]: + def unapply(x: Expr[Right[L, R]])(using Quotes): Option[Right[L, R]] = factory.apply().unapply(x) diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 78f4d4c8dba2..1416e4eaa590 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -106,12 +106,12 @@ object ToExpr extends LowPriorityToExpr { } /** Default implementation of `ToExpr[ClassTag[T]]`. Proxies to `ToExprFactory.classTagToExprFactory`. */ - given ClassTagToExpr: [T: Type] => ToExpr[ClassTag[T]]: - def apply(ct: ClassTag[T])(using Quotes): Expr[ClassTag[T]] = summon[ToExprFactory[ClassTag[T]]].apply().apply(ct) + given ClassTagToExpr: [T: Type] => (factory: ToExprFactory[ClassTag[T]]) => ToExpr[ClassTag[T]]: + def apply(ct: ClassTag[T])(using Quotes): Expr[ClassTag[T]] = factory.apply().apply(ct) /** Default implementation of `ToExpr[Array[T]]`. Proxies to `ToExprFactory.arrayToExprFactory`. */ - given ArrayToExpr: [T: {Type, ToExpr, ClassTag}] => ToExpr[Array[T]]: - def apply(arr: Array[T])(using Quotes): Expr[Array[T]] = summon[ToExprFactory[Array[T]]].apply().apply(arr) + given ArrayToExpr: [T: {Type, ToExpr, ClassTag}] => (factory: ToExprFactory[Array[T]]) => ToExpr[Array[T]]: + def apply(arr: Array[T])(using Quotes): Expr[Array[T]] = factory.apply().apply(arr) /** Default implementation of `ToExpr[Array[Boolean]]`. */ given ArrayOfBooleanToExpr: ToExpr[Array[Boolean]] with { @@ -176,12 +176,12 @@ object ToExpr extends LowPriorityToExpr { } /** Default implementation of `ToExpr[Seq[T]]`. Proxies to `ToExprFactory.seqToExprFactory`. */ - given SeqToExpr: [T: {Type, ToExpr}] => ToExpr[Seq[T]]: - def apply(xs: Seq[T])(using Quotes): Expr[Seq[T]] = summon[ToExprFactory[Seq[T]]].apply().apply(xs) + given SeqToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Seq[T]]) => ToExpr[Seq[T]]: + def apply(xs: Seq[T])(using Quotes): Expr[Seq[T]] = factory.apply().apply(xs) /** Default implementation of `ToExpr[List[T]]`. Proxies to `ToExprFactory.listToExprFactory`. */ - given ListToExpr: [T: {Type, ToExpr}] => ToExpr[List[T]]: - def apply(xs: List[T])(using Quotes): Expr[List[T]] = summon[ToExprFactory[List[T]]].apply().apply(xs) + given ListToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[List[T]]) => ToExpr[List[T]]: + def apply(xs: List[T])(using Quotes): Expr[List[T]] = factory.apply().apply(xs) /** Default implementation of `ToExpr[Nil.type]`. */ given NilToExpr: ToExpr[Nil.type] with { @@ -190,20 +190,20 @@ object ToExpr extends LowPriorityToExpr { } /** Default implementation of `ToExpr[Set[T]]`. Proxies to `ToExprFactory.setToExprFactory`. */ - given SetToExpr: [T: {Type, ToExpr}] => ToExpr[Set[T]]: - def apply(xs: Set[T])(using Quotes): Expr[Set[T]] = summon[ToExprFactory[Set[T]]].apply().apply(xs) + given SetToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Set[T]]) => ToExpr[Set[T]]: + def apply(xs: Set[T])(using Quotes): Expr[Set[T]] = factory.apply().apply(xs) /** Default implementation of `ToExpr[Map[T, U]]`. Proxies to `ToExprFactory.mapToExprFactory`. */ - given MapToExpr: [T: {Type, ToExpr}, U: {Type, ToExpr}] => ToExpr[Map[T, U]]: - def apply(m: Map[T, U])(using Quotes): Expr[Map[T, U]] = summon[ToExprFactory[Map[T, U]]].apply().apply(m) + given MapToExpr: [T: {Type, ToExpr}, U: {Type, ToExpr}] => (factory: ToExprFactory[Map[T, U]]) => ToExpr[Map[T, U]]: + def apply(m: Map[T, U])(using Quotes): Expr[Map[T, U]] = factory.apply().apply(m) /** Default implementation of `ToExpr[Option[T]]`. Proxies to `ToExprFactory.optionToExprFactory`. */ - given OptionToExpr: [T: {Type, ToExpr}] => ToExpr[Option[T]]: - def apply(x: Option[T])(using Quotes): Expr[Option[T]] = summon[ToExprFactory[Option[T]]].apply().apply(x) + given OptionToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Option[T]]) => ToExpr[Option[T]]: + def apply(x: Option[T])(using Quotes): Expr[Option[T]] = factory.apply().apply(x) /** Default implementation of `ToExpr[Some[T]]`. Proxies to `ToExprFactory.someToExprFactory`. */ - given SomeToExpr: [T: {Type, ToExpr}] => ToExpr[Some[T]]: - def apply(x: Some[T])(using Quotes): Expr[Some[T]] = summon[ToExprFactory[Some[T]]].apply().apply(x) + given SomeToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Some[T]]) => ToExpr[Some[T]]: + def apply(x: Some[T])(using Quotes): Expr[Some[T]] = factory.apply().apply(x) /** Default implementation of `ToExpr[None.type]`. */ given NoneToExpr: ToExpr[None.type] with { @@ -212,16 +212,16 @@ object ToExpr extends LowPriorityToExpr { } /** Default implementation of `ToExpr[Either[L, R]]`. Proxies to `ToExprFactory.eitherToExprFactory`. */ - given EitherToExpr: [L: {Type, ToExpr}, R: {Type, ToExpr}] => ToExpr[Either[L, R]]: - def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = summon[ToExprFactory[Either[L, R]]].apply().apply(x) + given EitherToExpr: [L: {Type, ToExpr}, R: {Type, ToExpr}] => (factory: ToExprFactory[Either[L, R]]) => ToExpr[Either[L, R]]: + def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = factory.apply().apply(x) /** Default implementation of `ToExpr[Left[L, R]]`. Proxies to `ToExprFactory.leftToExprFactory`. */ - given LeftToExpr: [L: {Type, ToExpr}, R: Type] => ToExpr[Left[L, R]]: - def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = summon[ToExprFactory[Left[L, R]]].apply().apply(x) + given LeftToExpr: [L: {Type, ToExpr}, R: Type] => (factory: ToExprFactory[Left[L, R]]) => ToExpr[Left[L, R]]: + def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = factory.apply().apply(x) /** Default implementation of `ToExpr[Right[L, R]]`. Proxies to `ToExprFactory.rightToExprFactory`. */ - given RightToExpr: [L: Type, R: {Type, ToExpr}] => ToExpr[Right[L, R]]: - def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = summon[ToExprFactory[Right[L, R]]].apply().apply(x) + given RightToExpr: [L: Type, R: {Type, ToExpr}] => (factory: ToExprFactory[Right[L, R]]) => ToExpr[Right[L, R]]: + def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = factory.apply().apply(x) /** Default implementation of `ToExpr[EmptyTuple.type]`. */ given EmptyTupleToExpr: ToExpr[EmptyTuple.type] with { @@ -229,181 +229,97 @@ object ToExpr extends LowPriorityToExpr { '{ EmptyTuple } } - /** Default implementation of `ToExpr[Tuple1[T1]]`. */ - given Tuple1ToExpr[T1: Type: ToExpr]: ToExpr[Tuple1[T1]] with { - def apply(tup: Tuple1[T1])(using Quotes) = - '{ Tuple1(${Expr(tup._1)}) } - } + /** Default implementation of `ToExpr[Tuple1[T1]]`. Proxies to `ToExprFactory.tuple1ToExprFactory`. */ + given Tuple1ToExpr: [T1: {Type, ToExpr}] => (factory: ToExprFactory[Tuple1[T1]]) => ToExpr[Tuple1[T1]]: + def apply(tup: Tuple1[T1])(using Quotes): Expr[Tuple1[T1]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple2[T1, T2]]`. */ - given Tuple2ToExpr[T1: Type: ToExpr, T2: Type: ToExpr]: ToExpr[Tuple2[T1, T2]] with { - def apply(tup: Tuple2[T1, T2])(using Quotes) = - '{ (${Expr(tup._1)}, ${Expr(tup._2)}) } - } + /** Default implementation of `ToExpr[Tuple2[T1, T2]]`. Proxies to `ToExprFactory.tuple2ToExprFactory`. */ + given Tuple2ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}] => (factory: ToExprFactory[Tuple2[T1, T2]]) => ToExpr[Tuple2[T1, T2]]: + def apply(tup: Tuple2[T1, T2])(using Quotes): Expr[Tuple2[T1, T2]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple3[T1, T2, T3]]`. */ - given Tuple3ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr]: ToExpr[Tuple3[T1, T2, T3]] with { - def apply(tup: Tuple3[T1, T2, T3])(using Quotes) = - '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}) } - } + /** Default implementation of `ToExpr[Tuple3[T1, T2, T3]]`. Proxies to `ToExprFactory.tuple3ToExprFactory`. */ + given Tuple3ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}] => (factory: ToExprFactory[Tuple3[T1, T2, T3]]) => ToExpr[Tuple3[T1, T2, T3]]: + def apply(tup: Tuple3[T1, T2, T3])(using Quotes): Expr[Tuple3[T1, T2, T3]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple4[T1, T2, T3, T4]]`. */ - given Tuple4ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr]: ToExpr[Tuple4[T1, T2, T3, T4]] with { - def apply(tup: Tuple4[T1, T2, T3, T4])(using Quotes) = - '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}) } - } + /** Default implementation of `ToExpr[Tuple4[T1, T2, T3, T4]]`. Proxies to `ToExprFactory.tuple4ToExprFactory`. */ + given Tuple4ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}] => (factory: ToExprFactory[Tuple4[T1, T2, T3, T4]]) => ToExpr[Tuple4[T1, T2, T3, T4]]: + def apply(tup: Tuple4[T1, T2, T3, T4])(using Quotes): Expr[Tuple4[T1, T2, T3, T4]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple5[T1, T2, T3, T4, T5]]`. */ - given Tuple5ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr]: ToExpr[Tuple5[T1, T2, T3, T4, T5]] with { - def apply(tup: Tuple5[T1, T2, T3, T4, T5])(using Quotes) = { - val (x1, x2, x3, x4, x5) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}) } - } - } + /** Default implementation of `ToExpr[Tuple5[T1, T2, T3, T4, T5]]`. Proxies to `ToExprFactory.tuple5ToExprFactory`. */ + given Tuple5ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}] => (factory: ToExprFactory[Tuple5[T1, T2, T3, T4, T5]]) => ToExpr[Tuple5[T1, T2, T3, T4, T5]]: + def apply(tup: Tuple5[T1, T2, T3, T4, T5])(using Quotes): Expr[Tuple5[T1, T2, T3, T4, T5]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]`. */ - given Tuple6ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr]: ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]] with { - def apply(tup: Tuple6[T1, T2, T3, T4, T5, T6])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}) } - } - } + /** Default implementation of `ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]`. Proxies to `ToExprFactory.tuple6ToExprFactory`. */ + given Tuple6ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}] => (factory: ToExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]) => ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: + def apply(tup: Tuple6[T1, T2, T3, T4, T5, T6])(using Quotes): Expr[Tuple6[T1, T2, T3, T4, T5, T6]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]`. */ - given Tuple7ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr]: ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] with { - def apply(tup: Tuple7[T1, T2, T3, T4, T5, T6, T7])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}) } - } - } + /** Default implementation of `ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]`. Proxies to `ToExprFactory.tuple7ToExprFactory`. */ + given Tuple7ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}] => (factory: ToExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]) => ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def apply(tup: Tuple7[T1, T2, T3, T4, T5, T6, T7])(using Quotes): Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]`. */ - given Tuple8ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr]: ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] with { - def apply(tup: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}) } - } - } + /** Default implementation of `ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]`. Proxies to `ToExprFactory.tuple8ToExprFactory`. */ + given Tuple8ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}] => (factory: ToExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]) => ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def apply(tup: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8])(using Quotes): Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]`. */ - given Tuple9ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr]: ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] with { - def apply(tup: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}) } - } - } + /** Default implementation of `ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]`. Proxies to `ToExprFactory.tuple9ToExprFactory`. */ + given Tuple9ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}] => (factory: ToExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]) => ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def apply(tup: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9])(using Quotes): Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]`. */ - given Tuple10ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr]: ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] with { - def apply(tup: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}) } - } - } + /** Default implementation of `ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]`. Proxies to `ToExprFactory.tuple10ToExprFactory`. */ + given Tuple10ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}] => (factory: ToExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]) => ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def apply(tup: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10])(using Quotes): Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]`. */ - given Tuple11ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr]: ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] with { - def apply(tup: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}) } - } - } + /** Default implementation of `ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]`. Proxies to `ToExprFactory.tuple11ToExprFactory`. */ + given Tuple11ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}] => (factory: ToExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]) => ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def apply(tup: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11])(using Quotes): Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]`. */ - given Tuple12ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr]: ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] with { - def apply(tup: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}) } - } - } + /** Default implementation of `ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]`. Proxies to `ToExprFactory.tuple12ToExprFactory`. */ + given Tuple12ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}] => (factory: ToExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]) => ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def apply(tup: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12])(using Quotes): Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]`. */ - given Tuple13ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr]: ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] with { - def apply(tup: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}) } - } - } + /** Default implementation of `ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]`. Proxies to `ToExprFactory.tuple13ToExprFactory`. */ + given Tuple13ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}] => (factory: ToExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]) => ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def apply(tup: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13])(using Quotes): Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]`. */ - given Tuple14ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr]: ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] with { - def apply(tup: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}) } - } - } + /** Default implementation of `ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]`. Proxies to `ToExprFactory.tuple14ToExprFactory`. */ + given Tuple14ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}] => (factory: ToExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]) => ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def apply(tup: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14])(using Quotes): Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]`. */ - given Tuple15ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr]: ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] with { - def apply(tup: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}) } - } - } + /** Default implementation of `ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]`. Proxies to `ToExprFactory.tuple15ToExprFactory`. */ + given Tuple15ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}] => (factory: ToExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]) => ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def apply(tup: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15])(using Quotes): Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]`. */ - given Tuple16ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr, T16: Type: ToExpr]: ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] with { - def apply(tup: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}) } - } - } + /** Default implementation of `ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]`. Proxies to `ToExprFactory.tuple16ToExprFactory`. */ + given Tuple16ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}] => (factory: ToExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]) => ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def apply(tup: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16])(using Quotes): Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]`. */ - given Tuple17ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr, T16: Type: ToExpr, T17: Type: ToExpr]: ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] with { - def apply(tup: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}) } - } - } + /** Default implementation of `ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]`. Proxies to `ToExprFactory.tuple17ToExprFactory`. */ + given Tuple17ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}] => (factory: ToExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]) => ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def apply(tup: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17])(using Quotes): Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]`. */ - given Tuple18ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr, T16: Type: ToExpr, T17: Type: ToExpr, T18: Type: ToExpr]: ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] with { - def apply(tup: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}) } - } - } + /** Default implementation of `ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]`. Proxies to `ToExprFactory.tuple18ToExprFactory`. */ + given Tuple18ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}] => (factory: ToExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]) => ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def apply(tup: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18])(using Quotes): Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]`. */ - given Tuple19ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr, T16: Type: ToExpr, T17: Type: ToExpr, T18: Type: ToExpr, T19: Type: ToExpr]: ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] with { - def apply(tup: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}) } - } - } + /** Default implementation of `ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]`. Proxies to `ToExprFactory.tuple19ToExprFactory`. */ + given Tuple19ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}] => (factory: ToExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]) => ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def apply(tup: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19])(using Quotes): Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]`. */ - given Tuple20ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr, T16: Type: ToExpr, T17: Type: ToExpr, T18: Type: ToExpr, T19: Type: ToExpr, T20: Type: ToExpr]: ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] with { - def apply(tup: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}, ${Expr(x20)}) } - } - } + /** Default implementation of `ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]`. Proxies to `ToExprFactory.tuple20ToExprFactory`. */ + given Tuple20ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}] => (factory: ToExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]) => ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def apply(tup: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20])(using Quotes): Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]`. */ - given Tuple21ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr, T16: Type: ToExpr, T17: Type: ToExpr, T18: Type: ToExpr, T19: Type: ToExpr, T20: Type: ToExpr, T21: Type: ToExpr]: ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] with { - def apply(tup: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}, ${Expr(x20)}, ${Expr(x21)}) } - } - } + /** Default implementation of `ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]`. Proxies to `ToExprFactory.tuple21ToExprFactory`. */ + given Tuple21ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}] => (factory: ToExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]) => ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def apply(tup: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21])(using Quotes): Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]`. */ - given Tuple22ToExpr[T1: Type: ToExpr, T2: Type: ToExpr, T3: Type: ToExpr, T4: Type: ToExpr, T5: Type: ToExpr, T6: Type: ToExpr, T7: Type: ToExpr, T8: Type: ToExpr, T9: Type: ToExpr, T10: Type: ToExpr, T11: Type: ToExpr, T12: Type: ToExpr, T13: Type: ToExpr, T14: Type: ToExpr, T15: Type: ToExpr, T16: Type: ToExpr, T17: Type: ToExpr, T18: Type: ToExpr, T19: Type: ToExpr, T20: Type: ToExpr, T21: Type: ToExpr, T22: Type: ToExpr]: ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] with { - def apply(tup: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22])(using Quotes) = { - val (x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15, x16, x17, x18, x19, x20, x21, x22) = tup - '{ (${Expr(x1)}, ${Expr(x2)}, ${Expr(x3)}, ${Expr(x4)}, ${Expr(x5)}, ${Expr(x6)}, ${Expr(x7)}, ${Expr(x8)}, ${Expr(x9)}, ${Expr(x10)}, ${Expr(x11)}, ${Expr(x12)}, ${Expr(x13)}, ${Expr(x14)}, ${Expr(x15)}, ${Expr(x16)}, ${Expr(x17)}, ${Expr(x18)}, ${Expr(x19)}, ${Expr(x20)}, ${Expr(x21)}, ${Expr(x22)}) } - } - } + /** Default implementation of `ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]`. Proxies to `ToExprFactory.tuple22ToExprFactory`. */ + given Tuple22ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}, T22: {Type, ToExpr}] => (factory: ToExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]) => ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def apply(tup: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22])(using Quotes): Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = factory.apply().apply(tup) - /** Default implementation of `ToExpr[H *: T]`. */ - given TupleConsToExpr [H: Type: ToExpr, T <: Tuple: Type: ToExpr]: ToExpr[H *: T] with { - def apply(tup: H *: T)(using Quotes): Expr[H *: T] = - val head = Expr[H](tup.head) - val tail = Expr[T](tup.tail) - '{ $head *: $tail } - } + /** Default implementation of `ToExpr[H *: T]`. Proxies to `ToExprFactory.tupleConsToExprFactory`. */ + given TupleConsToExpr: [H: {Type, ToExpr}, T <: Tuple: {Type, ToExpr}] => (factory: ToExprFactory[H *: T]) => ToExpr[H *: T]: + def apply(tup: H *: T)(using Quotes): Expr[H *: T] = factory.apply().apply(tup) /** Default implementation of `ToExpr[BigInt]`. */ given BigIntToExpr: ToExpr[BigInt] with { From b9dd49f0828e3b5648c37391c59aff2ccd0e02cd Mon Sep 17 00:00:00 2001 From: halotukozak Date: Thu, 16 Jul 2026 16:02:23 +0200 Subject: [PATCH 14/17] Restore pre-existing ToExpr/FromExpr given signatures for binary compatibility MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The container/tuple proxy instances (Option, Either, Seq, Map, Tuple1..22, etc.) previously used the new `given NAME: [T] => (factory: ...Factory[X]) => ...` shape, which changes the erased signature/return type of the old `given NAME(...): ToExpr[X] with { ... }` accessors and drops their named implementation classes — both binary incompatible with the released library. Each proxy is now a public `class NAME(...) extends ToExpr[X]`/`FromExpr[X]` plus a `final def NAME(...): NAME[...] = new NAME(...)`, mirroring the `ArrowAssoc` de-implicit pattern in Predef.scala: byte-identical to the pre-existing given-generated class + accessor, just no longer `given` and marked `@publicInBinary private[quoted]` so old compiled callers still link while new code resolves these via the ToExprFactory/FromExprFactory Mirror-based derivation instead. Bodies delegate to the new factories. Verified: mimaReportBinaryIssues (0 problems), the run-macros ToExpr/FromExpr test suites, and scala-cli format --check all pass. Co-Authored-By: Claude Sonnet 5 --- library/src/scala/quoted/FromExpr.scala | 333 ++++++++++++++++++------ library/src/scala/quoted/ToExpr.scala | 317 ++++++++++++++-------- 2 files changed, 457 insertions(+), 193 deletions(-) diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index d768c6eb43e8..ca7ff1ac00ec 100644 --- a/library/src/scala/quoted/FromExpr.scala +++ b/library/src/scala/quoted/FromExpr.scala @@ -1,7 +1,7 @@ package scala.quoted import language.experimental.captureChecking -import scala.annotation.{nowarn, tailrec} +import scala.annotation.publicInBinary /** A type class for types that can convert a `quoted.Expr[T]` to a `T`. * @@ -34,7 +34,7 @@ private[quoted] trait LowPriorityFromExpr: given fromFactory: [T: Type] => (f: FromExprFactory[T]) => FromExpr[T] = f.apply() /** Default given instances of `FromExpr`. */ -object FromExpr extends LowPriorityFromExpr: +object FromExpr extends LowPriorityFromExpr { /** Default implementation of `FromExpr[Boolean]` * - Transform `'{true}` into `Some(true)` @@ -115,8 +115,11 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{None}` into `Some(None)` * - Otherwise returns `None` */ - given OptionFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Option[T]]) => FromExpr[Option[T]]: - def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] = factory.apply().unapply(x) + class OptionFromExpr[T] @publicInBinary private[quoted] (using Type[T], FromExpr[T]) extends FromExpr[Option[T]]: + def unapply(x: Expr[Option[T]])(using Quotes): Option[Option[T]] = + FromExprFactory.optionFromExprFactory[T].apply().unapply(x) + + @publicInBinary private[quoted] final def OptionFromExpr[T](using Type[T], FromExpr[T]): OptionFromExpr[T] = new OptionFromExpr[T] /** Default implementation of `FromExpr[None]` * - Transform `'{None}` into `Some(None)` @@ -133,8 +136,11 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{Some(x)}` into `Some(Some(x))` if `x` can be transformed using `FromExpr[T]` * - Otherwise returns `None` */ - given SomeFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Some[T]]) => FromExpr[Some[T]]: - def unapply(x: Expr[Some[T]])(using Quotes): Option[Some[T]] = factory.apply().unapply(x) + class SomeFromExpr[T] @publicInBinary private[quoted] (using Type[T], FromExpr[T]) extends FromExpr[Some[T]]: + def unapply(x: Expr[Some[T]])(using Quotes): Option[Some[T]] = + FromExprFactory.someFromExprFactory[T].apply().unapply(x) + + @publicInBinary private[quoted] final def SomeFromExpr[T](using Type[T], FromExpr[T]): SomeFromExpr[T] = new SomeFromExpr[T] /** Default implementation of `FromExpr[StringContext]` * - Transform `'{StringContext(args*)}` into `Some(StringContext(args*))` if `args` is explicit and each one is liftable @@ -159,101 +165,236 @@ object FromExpr extends LowPriorityFromExpr: } } - /** Default implementation of `FromExpr[Tuple1[T1]]`. Proxies to `FromExprFactory.tuple1FromExprFactory`. */ - given Tuple1FromExpr: [T1: {Type, FromExpr}] => (factory: FromExprFactory[Tuple1[T1]]) => FromExpr[Tuple1[T1]]: - def unapply(x: Expr[Tuple1[T1]])(using Quotes): Option[Tuple1[T1]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple1[...]]` + * - Transform `'{Tuple1(x1)}` into `Some(Tuple1(x1))` if `x1` can be transformed using `FromExpr[T]` + * - Otherwise returns `None` + */ + class Tuple1FromExpr[T1] @publicInBinary private[quoted] (using Type[T1], FromExpr[T1]) extends FromExpr[Tuple1[T1]]: + def unapply(x: Expr[Tuple1[T1]])(using Quotes): Option[Tuple1[T1]] = + FromExprFactory.tuple1FromExprFactory[T1].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple2[T1, T2]]`. Proxies to `FromExprFactory.tuple2FromExprFactory`. */ - given Tuple2FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}] => (factory: FromExprFactory[Tuple2[T1, T2]]) => FromExpr[Tuple2[T1, T2]]: - def unapply(x: Expr[Tuple2[T1, T2]])(using Quotes): Option[Tuple2[T1, T2]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple1FromExpr[T1](using Type[T1], FromExpr[T1]): Tuple1FromExpr[T1] = new Tuple1FromExpr[T1] - /** Default implementation of `FromExpr[Tuple3[T1, T2, T3]]`. Proxies to `FromExprFactory.tuple3FromExprFactory`. */ - given Tuple3FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}] => (factory: FromExprFactory[Tuple3[T1, T2, T3]]) => FromExpr[Tuple3[T1, T2, T3]]: - def unapply(x: Expr[Tuple3[T1, T2, T3]])(using Quotes): Option[Tuple3[T1, T2, T3]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple2[...]]` + * - Transform `'{Tuple2(x1, x2)}` into `Some(Tuple2(x1, x2))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple2FromExpr[T1, T2] @publicInBinary private[quoted] (using Type[T1], Type[T2], FromExpr[T1], FromExpr[T2]) extends FromExpr[Tuple2[T1, T2]]: + def unapply(x: Expr[Tuple2[T1, T2]])(using Quotes): Option[Tuple2[T1, T2]] = + FromExprFactory.tuple2FromExprFactory[T1, T2].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple4[T1, T2, T3, T4]]`. Proxies to `FromExprFactory.tuple4FromExprFactory`. */ - given Tuple4FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}] => (factory: FromExprFactory[Tuple4[T1, T2, T3, T4]]) => FromExpr[Tuple4[T1, T2, T3, T4]]: - def unapply(x: Expr[Tuple4[T1, T2, T3, T4]])(using Quotes): Option[Tuple4[T1, T2, T3, T4]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple2FromExpr[T1, T2](using Type[T1], Type[T2], FromExpr[T1], FromExpr[T2]): Tuple2FromExpr[T1, T2] = new Tuple2FromExpr[T1, T2] - /** Default implementation of `FromExpr[Tuple5[T1, T2, T3, T4, T5]]`. Proxies to `FromExprFactory.tuple5FromExprFactory`. */ - given Tuple5FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}] => (factory: FromExprFactory[Tuple5[T1, T2, T3, T4, T5]]) => FromExpr[Tuple5[T1, T2, T3, T4, T5]]: - def unapply(x: Expr[Tuple5[T1, T2, T3, T4, T5]])(using Quotes): Option[Tuple5[T1, T2, T3, T4, T5]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple3[...]]` + * - Transform `'{Tuple3(x1, x2, x3)}` into `Some(Tuple3(x1, x2, x3))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple3FromExpr[T1, T2, T3] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], FromExpr[T1], FromExpr[T2], FromExpr[T3]) extends FromExpr[Tuple3[T1, T2, T3]]: + def unapply(x: Expr[Tuple3[T1, T2, T3]])(using Quotes): Option[Tuple3[T1, T2, T3]] = + FromExprFactory.tuple3FromExprFactory[T1, T2, T3].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]]`. Proxies to `FromExprFactory.tuple6FromExprFactory`. */ - given Tuple6FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}] => (factory: FromExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]) => FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: - def unapply(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]])(using Quotes): Option[Tuple6[T1, T2, T3, T4, T5, T6]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple3FromExpr[T1, T2, T3](using Type[T1], Type[T2], Type[T3], FromExpr[T1], FromExpr[T2], FromExpr[T3]): Tuple3FromExpr[T1, T2, T3] = new Tuple3FromExpr[T1, T2, T3] - /** Default implementation of `FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]`. Proxies to `FromExprFactory.tuple7FromExprFactory`. */ - given Tuple7FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}] => (factory: FromExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]) => FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: - def unapply(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]])(using Quotes): Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple4[...]]` + * - Transform `'{Tuple4(x1, ..., x4)}` into `Some(Tuple4(x1, ..., x4))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple4FromExpr[T1, T2, T3, T4] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4]) extends FromExpr[Tuple4[T1, T2, T3, T4]]: + def unapply(x: Expr[Tuple4[T1, T2, T3, T4]])(using Quotes): Option[Tuple4[T1, T2, T3, T4]] = + FromExprFactory.tuple4FromExprFactory[T1, T2, T3, T4].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]`. Proxies to `FromExprFactory.tuple8FromExprFactory`. */ - given Tuple8FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}] => (factory: FromExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]) => FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: - def unapply(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]])(using Quotes): Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple4FromExpr[T1, T2, T3, T4](using Type[T1], Type[T2], Type[T3], Type[T4], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4]): Tuple4FromExpr[T1, T2, T3, T4] = new Tuple4FromExpr[T1, T2, T3, T4] - /** Default implementation of `FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]`. Proxies to `FromExprFactory.tuple9FromExprFactory`. */ - given Tuple9FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}] => (factory: FromExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]) => FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: - def unapply(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]])(using Quotes): Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple5[...]]` + * - Transform `'{Tuple5(x1, ..., x5)}` into `Some(Tuple5(x1, ..., x5))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple5FromExpr[T1, T2, T3, T4, T5] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5]) extends FromExpr[Tuple5[T1, T2, T3, T4, T5]]: + def unapply(x: Expr[Tuple5[T1, T2, T3, T4, T5]])(using Quotes): Option[Tuple5[T1, T2, T3, T4, T5]] = + FromExprFactory.tuple5FromExprFactory[T1, T2, T3, T4, T5].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]`. Proxies to `FromExprFactory.tuple10FromExprFactory`. */ - given Tuple10FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}] => (factory: FromExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]) => FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: - def unapply(x: Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])(using Quotes): Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple5FromExpr[T1, T2, T3, T4, T5](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5]): Tuple5FromExpr[T1, T2, T3, T4, T5] = new Tuple5FromExpr[T1, T2, T3, T4, T5] - /** Default implementation of `FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]`. Proxies to `FromExprFactory.tuple11FromExprFactory`. */ - given Tuple11FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}] => (factory: FromExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]) => FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: - def unapply(x: Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]])(using Quotes): Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple6[...]]` + * - Transform `'{Tuple6(x1, ..., x6)}` into `Some(Tuple6(x1, ..., x6))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple6FromExpr[T1, T2, T3, T4, T5, T6] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6]) extends FromExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: + def unapply(x: Expr[Tuple6[T1, T2, T3, T4, T5, T6]])(using Quotes): Option[Tuple6[T1, T2, T3, T4, T5, T6]] = + FromExprFactory.tuple6FromExprFactory[T1, T2, T3, T4, T5, T6].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]`. Proxies to `FromExprFactory.tuple12FromExprFactory`. */ - given Tuple12FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}] => (factory: FromExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]) => FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: - def unapply(x: Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]])(using Quotes): Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple6FromExpr[T1, T2, T3, T4, T5, T6](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6]): Tuple6FromExpr[T1, T2, T3, T4, T5, T6] = new Tuple6FromExpr[T1, T2, T3, T4, T5, T6] - /** Default implementation of `FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]`. Proxies to `FromExprFactory.tuple13FromExprFactory`. */ - given Tuple13FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}] => (factory: FromExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]) => FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: - def unapply(x: Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]])(using Quotes): Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple7[...]]` + * - Transform `'{Tuple7(x1, ..., x7)}` into `Some(Tuple7(x1, ..., x7))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple7FromExpr[T1, T2, T3, T4, T5, T6, T7] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7]) extends FromExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def unapply(x: Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]])(using Quotes): Option[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = + FromExprFactory.tuple7FromExprFactory[T1, T2, T3, T4, T5, T6, T7].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]`. Proxies to `FromExprFactory.tuple14FromExprFactory`. */ - given Tuple14FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}] => (factory: FromExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]) => FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: - def unapply(x: Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]])(using Quotes): Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple7FromExpr[T1, T2, T3, T4, T5, T6, T7](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7]): Tuple7FromExpr[T1, T2, T3, T4, T5, T6, T7] = new Tuple7FromExpr[T1, T2, T3, T4, T5, T6, T7] - /** Default implementation of `FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]`. Proxies to `FromExprFactory.tuple15FromExprFactory`. */ - given Tuple15FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}] => (factory: FromExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]) => FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: - def unapply(x: Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]])(using Quotes): Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple8[...]]` + * - Transform `'{Tuple8(x1, ..., x8)}` into `Some(Tuple8(x1, ..., x8))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple8FromExpr[T1, T2, T3, T4, T5, T6, T7, T8] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8]) extends FromExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def unapply(x: Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]])(using Quotes): Option[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = + FromExprFactory.tuple8FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]`. Proxies to `FromExprFactory.tuple16FromExprFactory`. */ - given Tuple16FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}] => (factory: FromExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]) => FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: - def unapply(x: Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]])(using Quotes): Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple8FromExpr[T1, T2, T3, T4, T5, T6, T7, T8](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8]): Tuple8FromExpr[T1, T2, T3, T4, T5, T6, T7, T8] = new Tuple8FromExpr[T1, T2, T3, T4, T5, T6, T7, T8] - /** Default implementation of `FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]`. Proxies to `FromExprFactory.tuple17FromExprFactory`. */ - given Tuple17FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}] => (factory: FromExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]) => FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: - def unapply(x: Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]])(using Quotes): Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple9[...]]` + * - Transform `'{Tuple9(x1, ..., x9)}` into `Some(Tuple9(x1, ..., x9))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple9FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9]) extends FromExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def unapply(x: Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]])(using Quotes): Option[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = + FromExprFactory.tuple9FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]`. Proxies to `FromExprFactory.tuple18FromExprFactory`. */ - given Tuple18FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}] => (factory: FromExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]) => FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: - def unapply(x: Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]])(using Quotes): Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple9FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9]): Tuple9FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9] = new Tuple9FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9] - /** Default implementation of `FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]`. Proxies to `FromExprFactory.tuple19FromExprFactory`. */ - given Tuple19FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}] => (factory: FromExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]) => FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: - def unapply(x: Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]])(using Quotes): Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple10[...]]` + * - Transform `'{Tuple0(x1, ..., x10)}` into `Some(Tuple0(x1, ..., x10))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple10FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10]) extends FromExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def unapply(x: Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]])(using Quotes): Option[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = + FromExprFactory.tuple10FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple10FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10]): Tuple10FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = new Tuple10FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] + + /** Default implementation of `FromExpr[Tuple11[...]]` + * - Transform `'{Tuple1(x1, ..., x11)}` into `Some(Tuple1(x1, ..., x11))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple11FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11]) extends FromExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def unapply(x: Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]])(using Quotes): Option[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = + FromExprFactory.tuple11FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]`. Proxies to `FromExprFactory.tuple20FromExprFactory`. */ - given Tuple20FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}, T20: {Type, FromExpr}] => (factory: FromExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]) => FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: - def unapply(x: Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]])(using Quotes): Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple11FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11]): Tuple11FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] = new Tuple11FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] - /** Default implementation of `FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]`. Proxies to `FromExprFactory.tuple21FromExprFactory`. */ - given Tuple21FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}, T20: {Type, FromExpr}, T21: {Type, FromExpr}] => (factory: FromExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]) => FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: - def unapply(x: Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]])(using Quotes): Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = factory.apply().unapply(x) + /** Default implementation of `FromExpr[Tuple12[...]]` + * - Transform `'{Tuple2(x1, ..., x12)}` into `Some(Tuple2(x1, ..., x12))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple12FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12]) extends FromExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def unapply(x: Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]])(using Quotes): Option[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = + FromExprFactory.tuple12FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12].apply().unapply(x) - /** Default implementation of `FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]`. Proxies to `FromExprFactory.tuple22FromExprFactory`. */ - given Tuple22FromExpr: [T1: {Type, FromExpr}, T2: {Type, FromExpr}, T3: {Type, FromExpr}, T4: {Type, FromExpr}, T5: {Type, FromExpr}, T6: {Type, FromExpr}, T7: {Type, FromExpr}, T8: {Type, FromExpr}, T9: {Type, FromExpr}, T10: {Type, FromExpr}, T11: {Type, FromExpr}, T12: {Type, FromExpr}, T13: {Type, FromExpr}, T14: {Type, FromExpr}, T15: {Type, FromExpr}, T16: {Type, FromExpr}, T17: {Type, FromExpr}, T18: {Type, FromExpr}, T19: {Type, FromExpr}, T20: {Type, FromExpr}, T21: {Type, FromExpr}, T22: {Type, FromExpr}] => (factory: FromExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]) => FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: - def unapply(x: Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]])(using Quotes): Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = factory.apply().unapply(x) + @publicInBinary private[quoted] final def Tuple12FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12]): Tuple12FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] = new Tuple12FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] + + /** Default implementation of `FromExpr[Tuple13[...]]` + * - Transform `'{Tuple3(x1, ..., x13)}` into `Some(Tuple3(x1, ..., x13))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple13FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13]) extends FromExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def unapply(x: Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]])(using Quotes): Option[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = + FromExprFactory.tuple13FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple13FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13]): Tuple13FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] = new Tuple13FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] + + /** Default implementation of `FromExpr[Tuple14[...]]` + * - Transform `'{Tuple4(x1, ..., x14)}` into `Some(Tuple4(x1, ..., x14))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple14FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14]) extends FromExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def unapply(x: Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]])(using Quotes): Option[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = + FromExprFactory.tuple14FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple14FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14]): Tuple14FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] = new Tuple14FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] + + /** Default implementation of `FromExpr[Tuple15[...]]` + * - Transform `'{Tuple5(x1, ..., x15)}` into `Some(Tuple5(x1, ..., x15))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple15FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15]) extends FromExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def unapply(x: Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]])(using Quotes): Option[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = + FromExprFactory.tuple15FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple15FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15]): Tuple15FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] = new Tuple15FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] + + /** Default implementation of `FromExpr[Tuple16[...]]` + * - Transform `'{Tuple6(x1, ..., x16)}` into `Some(Tuple6(x1, ..., x16))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple16FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16]) extends FromExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def unapply(x: Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]])(using Quotes): Option[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = + FromExprFactory.tuple16FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple16FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16]): Tuple16FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] = new Tuple16FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] + + /** Default implementation of `FromExpr[Tuple17[...]]` + * - Transform `'{Tuple7(x1, ..., x17)}` into `Some(Tuple7(x1, ..., x17))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple17FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17]) extends FromExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def unapply(x: Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]])(using Quotes): Option[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = + FromExprFactory.tuple17FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple17FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17]): Tuple17FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] = new Tuple17FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] + + /** Default implementation of `FromExpr[Tuple18[...]]` + * - Transform `'{Tuple8(x1, ..., x18)}` into `Some(Tuple8(x1, ..., x18))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple18FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18]) extends FromExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def unapply(x: Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]])(using Quotes): Option[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = + FromExprFactory.tuple18FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple18FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18]): Tuple18FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] = new Tuple18FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] + + /** Default implementation of `FromExpr[Tuple19[...]]` + * - Transform `'{Tuple9(x1, ..., x19)}` into `Some(Tuple9(x1, ..., x19))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple19FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19]) extends FromExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def unapply(x: Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]])(using Quotes): Option[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = + FromExprFactory.tuple19FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple19FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19]): Tuple19FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] = new Tuple19FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] + + /** Default implementation of `FromExpr[Tuple20[...]]` + * - Transform `'{Tuple0(x1, ..., x20)}` into `Some(Tuple0(x1, ..., x20))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple20FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20]) extends FromExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def unapply(x: Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]])(using Quotes): Option[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = + FromExprFactory.tuple20FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple20FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20]): Tuple20FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] = new Tuple20FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] + + /** Default implementation of `FromExpr[Tuple21[...]]` + * - Transform `'{Tuple1(x1, ..., x21)}` into `Some(Tuple1(x1, ..., x21))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple21FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20], FromExpr[T21]) extends FromExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def unapply(x: Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]])(using Quotes): Option[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = + FromExprFactory.tuple21FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple21FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20], FromExpr[T21]): Tuple21FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] = new Tuple21FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] + + /** Default implementation of `FromExpr[Tuple22[...]]` + * - Transform `'{Tuple2(x1, ..., x22)}` into `Some(Tuple2(x1, ..., x22))` if all `xi` can be transformed using `FromExpr[Ti]` + * - Otherwise returns `None` + */ + class Tuple22FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] @publicInBinary private[quoted] (using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], Type[T22], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20], FromExpr[T21], FromExpr[T22]) extends FromExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def unapply(x: Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]])(using Quotes): Option[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = + FromExprFactory.tuple22FromExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22].apply().unapply(x) + + @publicInBinary private[quoted] final def Tuple22FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22](using Type[T1], Type[T2], Type[T3], Type[T4], Type[T5], Type[T6], Type[T7], Type[T8], Type[T9], Type[T10], Type[T11], Type[T12], Type[T13], Type[T14], Type[T15], Type[T16], Type[T17], Type[T18], Type[T19], Type[T20], Type[T21], Type[T22], FromExpr[T1], FromExpr[T2], FromExpr[T3], FromExpr[T4], FromExpr[T5], FromExpr[T6], FromExpr[T7], FromExpr[T8], FromExpr[T9], FromExpr[T10], FromExpr[T11], FromExpr[T12], FromExpr[T13], FromExpr[T14], FromExpr[T15], FromExpr[T16], FromExpr[T17], FromExpr[T18], FromExpr[T19], FromExpr[T20], FromExpr[T21], FromExpr[T22]): Tuple22FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] = new Tuple22FromExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] /** Default implementation of `FromExpr[Seq]` * - Transform `'{Seq(x1, ..., xn)}` into `Some(Seq(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform sequences that come out of varargs * - Otherwise returns `None` */ - given SeqFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Seq[T]]) => FromExpr[Seq[T]]: - def unapply(x: Expr[Seq[T]])(using Quotes): Option[Seq[T]] = factory.apply().unapply(x) + class SeqFromExpr[T] @publicInBinary private[quoted] (using Type[T], FromExpr[T]) extends FromExpr[Seq[T]]: + def unapply(x: Expr[Seq[T]])(using Quotes): Option[Seq[T]] = + FromExprFactory.seqFromExprFactory[T].apply().unapply(x) + + @publicInBinary private[quoted] final def SeqFromExpr[T](using Type[T], FromExpr[T]): SeqFromExpr[T] = new SeqFromExpr[T] /** Default implementation of `FromExpr[Nil]` * - Transform `'{Nil}` into `Some(Nil)` @@ -272,43 +413,63 @@ object FromExpr extends LowPriorityFromExpr: * - Transform `'{Nil}` into `Some(Nil)` * - Otherwise returns `None` */ - given ListFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[List[T]]) => FromExpr[List[T]]: - def unapply(x: Expr[List[T]])(using Quotes): Option[List[T]] = factory.apply().unapply(x) + class ListFromExpr[T] @publicInBinary private[quoted] (using Type[T], FromExpr[T]) extends FromExpr[List[T]]: + def unapply(x: Expr[List[T]])(using Quotes): Option[List[T]] = + FromExprFactory.listFromExprFactory[T].apply().unapply(x) + + @publicInBinary private[quoted] final def ListFromExpr[T](using Type[T], FromExpr[T]): ListFromExpr[T] = new ListFromExpr[T] /** Default implementation of `FromExpr[Set]` * - Transform `'{Set(x1, ..., xn)}` into `Some(Set(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform `'{Set.empty}` into `Some(Set())` * - Otherwise returns `None` */ - given SetFromExpr: [T: {Type, FromExpr}] => (factory: FromExprFactory[Set[T]]) => FromExpr[Set[T]]: - def unapply(x: Expr[Set[T]])(using Quotes): Option[Set[T]] = factory.apply().unapply(x) + class SetFromExpr[T] @publicInBinary private[quoted] (using Type[T], FromExpr[T]) extends FromExpr[Set[T]]: + def unapply(x: Expr[Set[T]])(using Quotes): Option[Set[T]] = + FromExprFactory.setFromExprFactory[T].apply().unapply(x) + + @publicInBinary private[quoted] final def SetFromExpr[T](using Type[T], FromExpr[T]): SetFromExpr[T] = new SetFromExpr[T] /** Default implementation of `FromExpr[Map]` * - Transform `'{Map(x1, ..., xn)}` into `Some(Map(x1, ..., xn))` if all `xi` can be transformed using `FromExpr[Ti]` * - Transform `'{Map.empty}` into `Some(Map())` * - Otherwise returns `None` */ - given MapFromExpr: [T: {Type, FromExpr}, U: {Type, FromExpr}] => (factory: FromExprFactory[Map[T, U]]) => FromExpr[Map[T, U]]: - def unapply(x: Expr[Map[T, U]])(using Quotes): Option[Map[T, U]] = factory.apply().unapply(x) + class MapFromExpr[T, U] @publicInBinary private[quoted] (using Type[T], Type[U], FromExpr[T], FromExpr[U]) extends FromExpr[Map[T, U]]: + def unapply(x: Expr[Map[T, U]])(using Quotes): Option[Map[T, U]] = + FromExprFactory.mapFromExprFactory[T, U].apply().unapply(x) + + @publicInBinary private[quoted] final def MapFromExpr[T, U](using Type[T], Type[U], FromExpr[T], FromExpr[U]): MapFromExpr[T, U] = new MapFromExpr[T, U] /** Default implementation of `FromExpr[Either]` * - Transform `'{Left(x)}` into `Some(Left(x))` if `x` can be transformed using `FromExpr[L]` * - Transform `'{Right(x)}` into `Some(Right(x))` if `x` can be transformed using `FromExpr[R]` * - Otherwise returns `None` */ - given EitherFromExpr: [L: {Type, FromExpr}, R: {Type, FromExpr}] => (factory: FromExprFactory[Either[L, R]]) => FromExpr[Either[L, R]]: - def unapply(x: Expr[Either[L, R]])(using Quotes): Option[Either[L, R]] = factory.apply().unapply(x) + class EitherFromExpr[L, R] @publicInBinary private[quoted] (using Type[L], Type[R], FromExpr[L], FromExpr[R]) extends FromExpr[Either[L, R]]: + def unapply(x: Expr[Either[L, R]])(using Quotes): Option[Either[L, R]] = + FromExprFactory.eitherFromExprFactory[L, R].apply().unapply(x) + + @publicInBinary private[quoted] final def EitherFromExpr[L, R](using Type[L], Type[R], FromExpr[L], FromExpr[R]): EitherFromExpr[L, R] = new EitherFromExpr[L, R] /** Default implementation of `FromExpr[Left]` * - Transform `'{Left(x)}` into `Some(Left(x))` if `x` can be transformed using `FromExpr[L]` * - Otherwise returns `None` */ - given LeftFromExpr: [L: {Type, FromExpr}, R: Type] => (factory: FromExprFactory[Left[L, R]]) => FromExpr[Left[L, R]]: - def unapply(x: Expr[Left[L, R]])(using Quotes): Option[Left[L, R]] = factory.apply().unapply(x) + class LeftFromExpr[L, R] @publicInBinary private[quoted] (using Type[L], Type[R], FromExpr[L]) extends FromExpr[Left[L, R]]: + def unapply(x: Expr[Left[L, R]])(using Quotes): Option[Left[L, R]] = + FromExprFactory.leftFromExprFactory[L, R].apply().unapply(x) + + @publicInBinary private[quoted] final def LeftFromExpr[L, R](using Type[L], Type[R], FromExpr[L]): LeftFromExpr[L, R] = new LeftFromExpr[L, R] /** Default implementation of `FromExpr[Right]` * - Transform `'{Right(x)}` into `Some(Right(x))` if `x` can be transformed using `FromExpr[R]` * - Otherwise returns `None` */ - given RightFromExpr: [L: Type, R: {Type, FromExpr}] => (factory: FromExprFactory[Right[L, R]]) => FromExpr[Right[L, R]]: - def unapply(x: Expr[Right[L, R]])(using Quotes): Option[Right[L, R]] = factory.apply().unapply(x) + class RightFromExpr[L, R] @publicInBinary private[quoted] (using Type[L], Type[R], FromExpr[R]) extends FromExpr[Right[L, R]]: + def unapply(x: Expr[Right[L, R]])(using Quotes): Option[Right[L, R]] = + FromExprFactory.rightFromExprFactory[L, R].apply().unapply(x) + + @publicInBinary private[quoted] final def RightFromExpr[L, R](using Type[L], Type[R], FromExpr[R]): RightFromExpr[L, R] = new RightFromExpr[L, R] + +} diff --git a/library/src/scala/quoted/ToExpr.scala b/library/src/scala/quoted/ToExpr.scala index 1416e4eaa590..9e0170b4fbda 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -1,20 +1,21 @@ package scala.quoted import language.experimental.captureChecking -import scala.annotation.nowarn + +import scala.annotation.publicInBinary import scala.reflect.ClassTag /** A type class for types that can convert a value of `T` into `quoted.Expr[T]` - * an expression that, when evaluated, produces a value equal to the original. + * an expression that, when evaluated, produces a value equal to the original. * - * @tparam T the type of the value to be lifted into an `Expr[T]` + * @tparam T the type of the value to be lifted into an `Expr[T]` */ trait ToExpr[T] { /** Lift a value into an expression containing the construction of that value. * - * @param x the value to lift into a quoted expression - * @return an `Expr[T]` that, when evaluated, produces a value equal to `x` + * @param x the value to lift into a quoted expression + * @return an `Expr[T]` that, when evaluated, produces a value equal to `x` */ def apply(x: T)(using Quotes): Expr[T] @@ -105,13 +106,19 @@ object ToExpr extends LowPriorityToExpr { } } - /** Default implementation of `ToExpr[ClassTag[T]]`. Proxies to `ToExprFactory.classTagToExprFactory`. */ - given ClassTagToExpr: [T: Type] => (factory: ToExprFactory[ClassTag[T]]) => ToExpr[ClassTag[T]]: - def apply(ct: ClassTag[T])(using Quotes): Expr[ClassTag[T]] = factory.apply().apply(ct) + /** Default implementation of `ToExpr[ClassTag[T]]`. */ + class ClassTagToExpr[T: Type] @publicInBinary private[quoted] extends ToExpr[ClassTag[T]]: + def apply(x: ClassTag[T])(using Quotes): Expr[ClassTag[T]] = + ToExprFactory.classTagToExprFactory[T].apply().apply(x) + + @publicInBinary private[quoted] final def ClassTagToExpr[T: Type]: ClassTagToExpr[T] = new ClassTagToExpr[T] + + /** Default implementation of `ToExpr[Array[T]]`. */ + class ArrayToExpr[T: {Type, ToExpr, ClassTag}] @publicInBinary private[quoted] extends ToExpr[Array[T]]: + def apply(x: Array[T])(using Quotes): Expr[Array[T]] = + ToExprFactory.arrayToExprFactory[T].apply().apply(x) - /** Default implementation of `ToExpr[Array[T]]`. Proxies to `ToExprFactory.arrayToExprFactory`. */ - given ArrayToExpr: [T: {Type, ToExpr, ClassTag}] => (factory: ToExprFactory[Array[T]]) => ToExpr[Array[T]]: - def apply(arr: Array[T])(using Quotes): Expr[Array[T]] = factory.apply().apply(arr) + @publicInBinary private[quoted] final def ArrayToExpr[T: {Type, ToExpr, ClassTag}]: ArrayToExpr[T] = new ArrayToExpr[T] /** Default implementation of `ToExpr[Array[Boolean]]`. */ given ArrayOfBooleanToExpr: ToExpr[Array[Boolean]] with { @@ -175,13 +182,19 @@ object ToExpr extends LowPriorityToExpr { '{ ${ltArray.apply(iarray.asInstanceOf[Array[T]])}.asInstanceOf[IArray[T]] } } - /** Default implementation of `ToExpr[Seq[T]]`. Proxies to `ToExprFactory.seqToExprFactory`. */ - given SeqToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Seq[T]]) => ToExpr[Seq[T]]: - def apply(xs: Seq[T])(using Quotes): Expr[Seq[T]] = factory.apply().apply(xs) + /** Default implementation of `ToExpr[Seq[T]]`. */ + class SeqToExpr[T: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Seq[T]]: + def apply(x: Seq[T])(using Quotes): Expr[Seq[T]] = + ToExprFactory.seqToExprFactory[T].apply().apply(x) + + @publicInBinary private[quoted] final def SeqToExpr[T: {Type, ToExpr}]: SeqToExpr[T] = new SeqToExpr[T] + + /** Default implementation of `ToExpr[List[T]]`. */ + class ListToExpr[T: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[List[T]]: + def apply(x: List[T])(using Quotes): Expr[List[T]] = + ToExprFactory.listToExprFactory[T].apply().apply(x) - /** Default implementation of `ToExpr[List[T]]`. Proxies to `ToExprFactory.listToExprFactory`. */ - given ListToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[List[T]]) => ToExpr[List[T]]: - def apply(xs: List[T])(using Quotes): Expr[List[T]] = factory.apply().apply(xs) + @publicInBinary private[quoted] final def ListToExpr[T: {Type, ToExpr}]: ListToExpr[T] = new ListToExpr[T] /** Default implementation of `ToExpr[Nil.type]`. */ given NilToExpr: ToExpr[Nil.type] with { @@ -189,21 +202,33 @@ object ToExpr extends LowPriorityToExpr { '{ Nil } } - /** Default implementation of `ToExpr[Set[T]]`. Proxies to `ToExprFactory.setToExprFactory`. */ - given SetToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Set[T]]) => ToExpr[Set[T]]: - def apply(xs: Set[T])(using Quotes): Expr[Set[T]] = factory.apply().apply(xs) + /** Default implementation of `ToExpr[Set[T]]`. */ + class SetToExpr[T: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Set[T]]: + def apply(x: Set[T])(using Quotes): Expr[Set[T]] = + ToExprFactory.setToExprFactory[T].apply().apply(x) + + @publicInBinary private[quoted] final def SetToExpr[T: {Type, ToExpr}]: SetToExpr[T] = new SetToExpr[T] + + /** Default implementation of `ToExpr[Map[T, U]]`. */ + class MapToExpr[T: {Type, ToExpr}, U: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Map[T, U]]: + def apply(x: Map[T, U])(using Quotes): Expr[Map[T, U]] = + ToExprFactory.mapToExprFactory[T, U].apply().apply(x) + + @publicInBinary private[quoted] final def MapToExpr[T: {Type, ToExpr}, U: {Type, ToExpr}]: MapToExpr[T, U] = new MapToExpr[T, U] + + /** Default implementation of `ToExpr[Option[T]]`. */ + class OptionToExpr[T: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Option[T]]: + def apply(x: Option[T])(using Quotes): Expr[Option[T]] = + ToExprFactory.optionToExprFactory[T].apply().apply(x) - /** Default implementation of `ToExpr[Map[T, U]]`. Proxies to `ToExprFactory.mapToExprFactory`. */ - given MapToExpr: [T: {Type, ToExpr}, U: {Type, ToExpr}] => (factory: ToExprFactory[Map[T, U]]) => ToExpr[Map[T, U]]: - def apply(m: Map[T, U])(using Quotes): Expr[Map[T, U]] = factory.apply().apply(m) + @publicInBinary private[quoted] final def OptionToExpr[T: {Type, ToExpr}]: OptionToExpr[T] = new OptionToExpr[T] - /** Default implementation of `ToExpr[Option[T]]`. Proxies to `ToExprFactory.optionToExprFactory`. */ - given OptionToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Option[T]]) => ToExpr[Option[T]]: - def apply(x: Option[T])(using Quotes): Expr[Option[T]] = factory.apply().apply(x) + /** Default implementation of `ToExpr[Some[T]]`. */ + class SomeToExpr[T: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Some[T]]: + def apply(x: Some[T])(using Quotes): Expr[Some[T]] = + ToExprFactory.someToExprFactory[T].apply().apply(x) - /** Default implementation of `ToExpr[Some[T]]`. Proxies to `ToExprFactory.someToExprFactory`. */ - given SomeToExpr: [T: {Type, ToExpr}] => (factory: ToExprFactory[Some[T]]) => ToExpr[Some[T]]: - def apply(x: Some[T])(using Quotes): Expr[Some[T]] = factory.apply().apply(x) + @publicInBinary private[quoted] final def SomeToExpr[T: {Type, ToExpr}]: SomeToExpr[T] = new SomeToExpr[T] /** Default implementation of `ToExpr[None.type]`. */ given NoneToExpr: ToExpr[None.type] with { @@ -211,17 +236,26 @@ object ToExpr extends LowPriorityToExpr { '{ None } } - /** Default implementation of `ToExpr[Either[L, R]]`. Proxies to `ToExprFactory.eitherToExprFactory`. */ - given EitherToExpr: [L: {Type, ToExpr}, R: {Type, ToExpr}] => (factory: ToExprFactory[Either[L, R]]) => ToExpr[Either[L, R]]: - def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = factory.apply().apply(x) + /** Default implementation of `ToExpr[Either[L, R]]`. */ + class EitherToExpr[L: {Type, ToExpr}, R: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Either[L, R]]: + def apply(x: Either[L, R])(using Quotes): Expr[Either[L, R]] = + ToExprFactory.eitherToExprFactory[L, R].apply().apply(x) - /** Default implementation of `ToExpr[Left[L, R]]`. Proxies to `ToExprFactory.leftToExprFactory`. */ - given LeftToExpr: [L: {Type, ToExpr}, R: Type] => (factory: ToExprFactory[Left[L, R]]) => ToExpr[Left[L, R]]: - def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = factory.apply().apply(x) + @publicInBinary private[quoted] final def EitherToExpr[L: {Type, ToExpr}, R: {Type, ToExpr}]: EitherToExpr[L, R] = new EitherToExpr[L, R] - /** Default implementation of `ToExpr[Right[L, R]]`. Proxies to `ToExprFactory.rightToExprFactory`. */ - given RightToExpr: [L: Type, R: {Type, ToExpr}] => (factory: ToExprFactory[Right[L, R]]) => ToExpr[Right[L, R]]: - def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = factory.apply().apply(x) + /** Default implementation of `ToExpr[Left[L, R]]`. */ + class LeftToExpr[L: {Type, ToExpr}, R: Type] @publicInBinary private[quoted] extends ToExpr[Left[L, R]]: + def apply(x: Left[L, R])(using Quotes): Expr[Left[L, R]] = + ToExprFactory.leftToExprFactory[L, R].apply().apply(x) + + @publicInBinary private[quoted] final def LeftToExpr[L: {Type, ToExpr}, R: Type]: LeftToExpr[L, R] = new LeftToExpr[L, R] + + /** Default implementation of `ToExpr[Right[L, R]]`. */ + class RightToExpr[L: Type, R: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Right[L, R]]: + def apply(x: Right[L, R])(using Quotes): Expr[Right[L, R]] = + ToExprFactory.rightToExprFactory[L, R].apply().apply(x) + + @publicInBinary private[quoted] final def RightToExpr[L: Type, R: {Type, ToExpr}]: RightToExpr[L, R] = new RightToExpr[L, R] /** Default implementation of `ToExpr[EmptyTuple.type]`. */ given EmptyTupleToExpr: ToExpr[EmptyTuple.type] with { @@ -229,97 +263,166 @@ object ToExpr extends LowPriorityToExpr { '{ EmptyTuple } } - /** Default implementation of `ToExpr[Tuple1[T1]]`. Proxies to `ToExprFactory.tuple1ToExprFactory`. */ - given Tuple1ToExpr: [T1: {Type, ToExpr}] => (factory: ToExprFactory[Tuple1[T1]]) => ToExpr[Tuple1[T1]]: - def apply(tup: Tuple1[T1])(using Quotes): Expr[Tuple1[T1]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple1[T1]]`. */ + class Tuple1ToExpr[T1: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple1[T1]]: + def apply(x: Tuple1[T1])(using Quotes): Expr[Tuple1[T1]] = + ToExprFactory.tuple1ToExprFactory[T1].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple1ToExpr[T1: {Type, ToExpr}]: Tuple1ToExpr[T1] = new Tuple1ToExpr[T1] + + /** Default implementation of `ToExpr[Tuple2[T1, T2]]`. */ + class Tuple2ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple2[T1, T2]]: + def apply(x: Tuple2[T1, T2])(using Quotes): Expr[Tuple2[T1, T2]] = + ToExprFactory.tuple2ToExprFactory[T1, T2].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple2ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}]: Tuple2ToExpr[T1, T2] = new Tuple2ToExpr[T1, T2] + + /** Default implementation of `ToExpr[Tuple3[T1, T2, T3]]`. */ + class Tuple3ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple3[T1, T2, T3]]: + def apply(x: Tuple3[T1, T2, T3])(using Quotes): Expr[Tuple3[T1, T2, T3]] = + ToExprFactory.tuple3ToExprFactory[T1, T2, T3].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple3ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}]: Tuple3ToExpr[T1, T2, T3] = new Tuple3ToExpr[T1, T2, T3] + + /** Default implementation of `ToExpr[Tuple4[T1, T2, T3, T4]]`. */ + class Tuple4ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple4[T1, T2, T3, T4]]: + def apply(x: Tuple4[T1, T2, T3, T4])(using Quotes): Expr[Tuple4[T1, T2, T3, T4]] = + ToExprFactory.tuple4ToExprFactory[T1, T2, T3, T4].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple4ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}]: Tuple4ToExpr[T1, T2, T3, T4] = new Tuple4ToExpr[T1, T2, T3, T4] + + /** Default implementation of `ToExpr[Tuple5[T1, T2, T3, T4, T5]]`. */ + class Tuple5ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple5[T1, T2, T3, T4, T5]]: + def apply(x: Tuple5[T1, T2, T3, T4, T5])(using Quotes): Expr[Tuple5[T1, T2, T3, T4, T5]] = + ToExprFactory.tuple5ToExprFactory[T1, T2, T3, T4, T5].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple5ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}]: Tuple5ToExpr[T1, T2, T3, T4, T5] = new Tuple5ToExpr[T1, T2, T3, T4, T5] + + /** Default implementation of `ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]`. */ + class Tuple6ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: + def apply(x: Tuple6[T1, T2, T3, T4, T5, T6])(using Quotes): Expr[Tuple6[T1, T2, T3, T4, T5, T6]] = + ToExprFactory.tuple6ToExprFactory[T1, T2, T3, T4, T5, T6].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple6ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}]: Tuple6ToExpr[T1, T2, T3, T4, T5, T6] = new Tuple6ToExpr[T1, T2, T3, T4, T5, T6] + + /** Default implementation of `ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]`. */ + class Tuple7ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: + def apply(x: Tuple7[T1, T2, T3, T4, T5, T6, T7])(using Quotes): Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = + ToExprFactory.tuple7ToExprFactory[T1, T2, T3, T4, T5, T6, T7].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple7ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}]: Tuple7ToExpr[T1, T2, T3, T4, T5, T6, T7] = new Tuple7ToExpr[T1, T2, T3, T4, T5, T6, T7] + + /** Default implementation of `ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]`. */ + class Tuple8ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: + def apply(x: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8])(using Quotes): Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = + ToExprFactory.tuple8ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple8ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}]: Tuple8ToExpr[T1, T2, T3, T4, T5, T6, T7, T8] = new Tuple8ToExpr[T1, T2, T3, T4, T5, T6, T7, T8] + + /** Default implementation of `ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]`. */ + class Tuple9ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: + def apply(x: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9])(using Quotes): Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = + ToExprFactory.tuple9ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple9ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}]: Tuple9ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9] = new Tuple9ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9] + + /** Default implementation of `ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]`. */ + class Tuple10ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: + def apply(x: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10])(using Quotes): Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = + ToExprFactory.tuple10ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple10ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}]: Tuple10ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] = new Tuple10ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10] + + /** Default implementation of `ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]`. */ + class Tuple11ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: + def apply(x: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11])(using Quotes): Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = + ToExprFactory.tuple11ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple11ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}]: Tuple11ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] = new Tuple11ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11] + + /** Default implementation of `ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]`. */ + class Tuple12ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: + def apply(x: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12])(using Quotes): Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = + ToExprFactory.tuple12ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12].apply().apply(x) + + @publicInBinary private[quoted] final def Tuple12ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}]: Tuple12ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] = new Tuple12ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12] - /** Default implementation of `ToExpr[Tuple2[T1, T2]]`. Proxies to `ToExprFactory.tuple2ToExprFactory`. */ - given Tuple2ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}] => (factory: ToExprFactory[Tuple2[T1, T2]]) => ToExpr[Tuple2[T1, T2]]: - def apply(tup: Tuple2[T1, T2])(using Quotes): Expr[Tuple2[T1, T2]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]`. */ + class Tuple13ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: + def apply(x: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13])(using Quotes): Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = + ToExprFactory.tuple13ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13].apply().apply(x) - /** Default implementation of `ToExpr[Tuple3[T1, T2, T3]]`. Proxies to `ToExprFactory.tuple3ToExprFactory`. */ - given Tuple3ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}] => (factory: ToExprFactory[Tuple3[T1, T2, T3]]) => ToExpr[Tuple3[T1, T2, T3]]: - def apply(tup: Tuple3[T1, T2, T3])(using Quotes): Expr[Tuple3[T1, T2, T3]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple13ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}]: Tuple13ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] = new Tuple13ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13] - /** Default implementation of `ToExpr[Tuple4[T1, T2, T3, T4]]`. Proxies to `ToExprFactory.tuple4ToExprFactory`. */ - given Tuple4ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}] => (factory: ToExprFactory[Tuple4[T1, T2, T3, T4]]) => ToExpr[Tuple4[T1, T2, T3, T4]]: - def apply(tup: Tuple4[T1, T2, T3, T4])(using Quotes): Expr[Tuple4[T1, T2, T3, T4]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]`. */ + class Tuple14ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: + def apply(x: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14])(using Quotes): Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = + ToExprFactory.tuple14ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14].apply().apply(x) - /** Default implementation of `ToExpr[Tuple5[T1, T2, T3, T4, T5]]`. Proxies to `ToExprFactory.tuple5ToExprFactory`. */ - given Tuple5ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}] => (factory: ToExprFactory[Tuple5[T1, T2, T3, T4, T5]]) => ToExpr[Tuple5[T1, T2, T3, T4, T5]]: - def apply(tup: Tuple5[T1, T2, T3, T4, T5])(using Quotes): Expr[Tuple5[T1, T2, T3, T4, T5]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple14ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}]: Tuple14ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] = new Tuple14ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14] - /** Default implementation of `ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]`. Proxies to `ToExprFactory.tuple6ToExprFactory`. */ - given Tuple6ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}] => (factory: ToExprFactory[Tuple6[T1, T2, T3, T4, T5, T6]]) => ToExpr[Tuple6[T1, T2, T3, T4, T5, T6]]: - def apply(tup: Tuple6[T1, T2, T3, T4, T5, T6])(using Quotes): Expr[Tuple6[T1, T2, T3, T4, T5, T6]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]`. */ + class Tuple15ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: + def apply(x: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15])(using Quotes): Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = + ToExprFactory.tuple15ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15].apply().apply(x) - /** Default implementation of `ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]`. Proxies to `ToExprFactory.tuple7ToExprFactory`. */ - given Tuple7ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}] => (factory: ToExprFactory[Tuple7[T1, T2, T3, T4, T5, T6, T7]]) => ToExpr[Tuple7[T1, T2, T3, T4, T5, T6, T7]]: - def apply(tup: Tuple7[T1, T2, T3, T4, T5, T6, T7])(using Quotes): Expr[Tuple7[T1, T2, T3, T4, T5, T6, T7]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple15ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}]: Tuple15ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] = new Tuple15ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15] - /** Default implementation of `ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]`. Proxies to `ToExprFactory.tuple8ToExprFactory`. */ - given Tuple8ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}] => (factory: ToExprFactory[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]) => ToExpr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]]: - def apply(tup: Tuple8[T1, T2, T3, T4, T5, T6, T7, T8])(using Quotes): Expr[Tuple8[T1, T2, T3, T4, T5, T6, T7, T8]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]`. */ + class Tuple16ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: + def apply(x: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16])(using Quotes): Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = + ToExprFactory.tuple16ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16].apply().apply(x) - /** Default implementation of `ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]`. Proxies to `ToExprFactory.tuple9ToExprFactory`. */ - given Tuple9ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}] => (factory: ToExprFactory[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]) => ToExpr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]]: - def apply(tup: Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9])(using Quotes): Expr[Tuple9[T1, T2, T3, T4, T5, T6, T7, T8, T9]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple16ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}]: Tuple16ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] = new Tuple16ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16] - /** Default implementation of `ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]`. Proxies to `ToExprFactory.tuple10ToExprFactory`. */ - given Tuple10ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}] => (factory: ToExprFactory[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]) => ToExpr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]]: - def apply(tup: Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10])(using Quotes): Expr[Tuple10[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]`. */ + class Tuple17ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: + def apply(x: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17])(using Quotes): Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = + ToExprFactory.tuple17ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17].apply().apply(x) - /** Default implementation of `ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]`. Proxies to `ToExprFactory.tuple11ToExprFactory`. */ - given Tuple11ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}] => (factory: ToExprFactory[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]) => ToExpr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]]: - def apply(tup: Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11])(using Quotes): Expr[Tuple11[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple17ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}]: Tuple17ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] = new Tuple17ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17] - /** Default implementation of `ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]`. Proxies to `ToExprFactory.tuple12ToExprFactory`. */ - given Tuple12ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}] => (factory: ToExprFactory[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]) => ToExpr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]]: - def apply(tup: Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12])(using Quotes): Expr[Tuple12[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]`. */ + class Tuple18ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: + def apply(x: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18])(using Quotes): Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = + ToExprFactory.tuple18ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18].apply().apply(x) - /** Default implementation of `ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]`. Proxies to `ToExprFactory.tuple13ToExprFactory`. */ - given Tuple13ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}] => (factory: ToExprFactory[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]) => ToExpr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]]: - def apply(tup: Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13])(using Quotes): Expr[Tuple13[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple18ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}]: Tuple18ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] = new Tuple18ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18] - /** Default implementation of `ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]`. Proxies to `ToExprFactory.tuple14ToExprFactory`. */ - given Tuple14ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}] => (factory: ToExprFactory[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]) => ToExpr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]]: - def apply(tup: Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14])(using Quotes): Expr[Tuple14[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]`. */ + class Tuple19ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: + def apply(x: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19])(using Quotes): Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = + ToExprFactory.tuple19ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19].apply().apply(x) - /** Default implementation of `ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]`. Proxies to `ToExprFactory.tuple15ToExprFactory`. */ - given Tuple15ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}] => (factory: ToExprFactory[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]) => ToExpr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]]: - def apply(tup: Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15])(using Quotes): Expr[Tuple15[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple19ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}]: Tuple19ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] = new Tuple19ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19] - /** Default implementation of `ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]`. Proxies to `ToExprFactory.tuple16ToExprFactory`. */ - given Tuple16ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}] => (factory: ToExprFactory[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]) => ToExpr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]]: - def apply(tup: Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16])(using Quotes): Expr[Tuple16[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]`. */ + class Tuple20ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: + def apply(x: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20])(using Quotes): Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = + ToExprFactory.tuple20ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20].apply().apply(x) - /** Default implementation of `ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]`. Proxies to `ToExprFactory.tuple17ToExprFactory`. */ - given Tuple17ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}] => (factory: ToExprFactory[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]) => ToExpr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]]: - def apply(tup: Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17])(using Quotes): Expr[Tuple17[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple20ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}]: Tuple20ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] = new Tuple20ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20] - /** Default implementation of `ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]`. Proxies to `ToExprFactory.tuple18ToExprFactory`. */ - given Tuple18ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}] => (factory: ToExprFactory[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]) => ToExpr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]]: - def apply(tup: Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18])(using Quotes): Expr[Tuple18[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]`. */ + class Tuple21ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: + def apply(x: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21])(using Quotes): Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = + ToExprFactory.tuple21ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21].apply().apply(x) - /** Default implementation of `ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]`. Proxies to `ToExprFactory.tuple19ToExprFactory`. */ - given Tuple19ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}] => (factory: ToExprFactory[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]) => ToExpr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]]: - def apply(tup: Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19])(using Quotes): Expr[Tuple19[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple21ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}]: Tuple21ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] = new Tuple21ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21] - /** Default implementation of `ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]`. Proxies to `ToExprFactory.tuple20ToExprFactory`. */ - given Tuple20ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}] => (factory: ToExprFactory[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]) => ToExpr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]]: - def apply(tup: Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20])(using Quotes): Expr[Tuple20[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]`. */ + class Tuple22ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}, T22: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: + def apply(x: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22])(using Quotes): Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = + ToExprFactory.tuple22ToExprFactory[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22].apply().apply(x) - /** Default implementation of `ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]`. Proxies to `ToExprFactory.tuple21ToExprFactory`. */ - given Tuple21ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}] => (factory: ToExprFactory[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]) => ToExpr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]]: - def apply(tup: Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21])(using Quotes): Expr[Tuple21[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21]] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def Tuple22ToExpr[T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}, T22: {Type, ToExpr}]: Tuple22ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] = new Tuple22ToExpr[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22] - /** Default implementation of `ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]`. Proxies to `ToExprFactory.tuple22ToExprFactory`. */ - given Tuple22ToExpr: [T1: {Type, ToExpr}, T2: {Type, ToExpr}, T3: {Type, ToExpr}, T4: {Type, ToExpr}, T5: {Type, ToExpr}, T6: {Type, ToExpr}, T7: {Type, ToExpr}, T8: {Type, ToExpr}, T9: {Type, ToExpr}, T10: {Type, ToExpr}, T11: {Type, ToExpr}, T12: {Type, ToExpr}, T13: {Type, ToExpr}, T14: {Type, ToExpr}, T15: {Type, ToExpr}, T16: {Type, ToExpr}, T17: {Type, ToExpr}, T18: {Type, ToExpr}, T19: {Type, ToExpr}, T20: {Type, ToExpr}, T21: {Type, ToExpr}, T22: {Type, ToExpr}] => (factory: ToExprFactory[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]) => ToExpr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]]: - def apply(tup: Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22])(using Quotes): Expr[Tuple22[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22]] = factory.apply().apply(tup) + /** Default implementation of `ToExpr[H *: T]`. */ + class TupleConsToExpr [H: {Type, ToExpr}, T <: Tuple: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[H *: T]: + def apply(x: H *: T)(using Quotes): Expr[H *: T] = + ToExprFactory.tupleConsToExprFactory[H, T].apply().apply(x) - /** Default implementation of `ToExpr[H *: T]`. Proxies to `ToExprFactory.tupleConsToExprFactory`. */ - given TupleConsToExpr: [H: {Type, ToExpr}, T <: Tuple: {Type, ToExpr}] => (factory: ToExprFactory[H *: T]) => ToExpr[H *: T]: - def apply(tup: H *: T)(using Quotes): Expr[H *: T] = factory.apply().apply(tup) + @publicInBinary private[quoted] final def TupleConsToExpr [H: {Type, ToExpr}, T <: Tuple: {Type, ToExpr}]: TupleConsToExpr[H, T] = new TupleConsToExpr[H, T] /** Default implementation of `ToExpr[BigInt]`. */ given BigIntToExpr: ToExpr[BigInt] with { From 68ced9eda63298d495e3d37f5883a23ac7f13277 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Wed, 12 Aug 2026 13:13:14 +0200 Subject: [PATCH 15/17] fix derivedSum in ToExprFactory --- library/src/scala/quoted/ToExprFactory.scala | 15 ++++++++++----- 1 file changed, 10 insertions(+), 5 deletions(-) diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index 13e4e1aaabb4..bbf39fa51d0e 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -1,6 +1,7 @@ package scala.quoted import language.experimental.captureChecking +import scala.annotation.tailrec import scala.deriving.Mirror import scala.reflect.ClassTag @@ -51,11 +52,15 @@ object ToExprFactory: def apply(x: T)(using quotes: Quotes): Expr[T] = import quotes.reflect.* val idx = m.ordinal(x) - val caseSym = TypeRepr.of[T].typeSymbol.children(idx) - // Parameterless enum cases (`case Red, Green`) are terms, not types; use termRef for those. - val ref = if caseSym.isTerm then caseSym.termRef else caseSym.typeRef - ref.asType match - case '[c] => elems(idx).asInstanceOf[ToExprFactory[c]].apply().apply(x.asInstanceOf[c]).asInstanceOf[Expr[T]] + // Re-derive `MirroredElemTypes` at this splice site instead of trusting the case symbol's + // bare `typeRef`: for a generic sum (e.g. `Result[+A]`), the symbol alone loses the type + // arguments (`Ok` instead of `Ok[Int]`). + @tailrec def elemTypeAt(n: Int, elemTypes: TypeRepr): TypeRepr = elemTypes.asType match + case '[h *: t] => if n == 0 then TypeRepr.of[h] else elemTypeAt(n - 1, TypeRepr.of[t]) + Expr.summon[Mirror.SumOf[T]].get match + case '{ $_ : Mirror.SumOf[T] { type MirroredElemTypes = elemTypes } } => + elemTypeAt(idx, TypeRepr.of[elemTypes]).asType match + case '[c] => elems(idx).asInstanceOf[ToExprFactory[c]].apply().apply(x.asInstanceOf[c]).asExprOf[T] /** Bridges any type that already has a plain `ToExpr` (e.g. `Int`, `String`) into `ToExprFactory`. */ given fromToExpr: [T] => (te: ToExpr[T]) => ToExprFactory[T]: From 8caec3d54d4729845cfe29e9121307b5077c23aa Mon Sep 17 00:00:00 2001 From: halotukozak Date: Thu, 13 Aug 2026 15:09:40 +0200 Subject: [PATCH 16/17] fix derivedSum in FromExprFactory --- library/src/scala/quoted/FromExprFactory.scala | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/library/src/scala/quoted/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala index 39ec4a61bb11..ce58825f9dac 100644 --- a/library/src/scala/quoted/FromExprFactory.scala +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -83,12 +83,17 @@ object FromExprFactory: def apply()(using Type[T]): FromExpr[T] = new FromExpr[T]: def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = import quotes.reflect.* - val caseSyms = TypeRepr.of[T].typeSymbol.children - val resolvedElems: List[FromExpr[Any]] = elems.zip(caseSyms).map: - case (factory, caseSym) => - // Parameterless enum cases (`case Red, Green`) are terms, not types; use termRef for those. - val ref = if caseSym.isTerm then caseSym.termRef else caseSym.typeRef - ref.asType match + // Re-derive `MirroredElemTypes` at this splice site instead of trusting the case symbols' + // bare `typeRef`: for a generic sum (e.g. `Result[+A]`), the symbol alone loses the type + // arguments (`Ok` instead of `Ok[Int]`). + def elemTypesOf(elemTypes: TypeRepr): List[TypeRepr] = elemTypes.asType match + case '[EmptyTuple] => Nil + case '[h *: t] => TypeRepr.of[h] :: elemTypesOf(TypeRepr.of[t]) + val elemTypeReprs = Expr.summon[Mirror.SumOf[T]].get match + case '{ $_ : Mirror.SumOf[T] { type MirroredElemTypes = elemTypes } } => elemTypesOf(TypeRepr.of[elemTypes]) + val resolvedElems: List[FromExpr[Any]] = elems.zip(elemTypeReprs).map: + case (factory, elemType) => + elemType.asType match case '[c] => factory.asInstanceOf[FromExprFactory[c]].apply().asInstanceOf[FromExpr[Any]] resolvedElems.iterator.map(_.unapply(x)).collectFirst { case Some(v) => v.asInstanceOf[T] } From 03c965435e10468b3ff0d0607e8bf951331d48f0 Mon Sep 17 00:00:00 2001 From: halotukozak Date: Thu, 13 Aug 2026 15:51:53 +0200 Subject: [PATCH 17/17] Demote tupleConsToExprFactory to a low-priority fallback Having it at the same priority as the direct tuple1..22ToExprFactory instances made implicit search explore the recursive candidate (and its own H/T sub-searches) at every nesting level before it could rule it out as less specific. For tuples of arity ~20+ that branching blows past -Ximplicit-search-limit and search fails outright - the "was not imported with `import given`" note in the resulting error is a red herring from the separate, relaxed search the compiler runs just for error reporting. Moving the cons instance into a LowPriorityToExprFactory supertype (mirroring LowPriorityToExpr/LowestPriorityToExpr already used for the ToExpr <-> ToExprFactory bridge) means the direct instance is found first and search stops there for arity <= 22; the recursive fallback still handles arity > 22 without the ambiguity. --- library/src/scala/quoted/ToExprFactory.scala | 24 ++++++++++---------- 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala index bbf39fa51d0e..2acccf90578d 100644 --- a/library/src/scala/quoted/ToExprFactory.scala +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -14,7 +14,18 @@ import scala.reflect.ClassTag trait ToExprFactory[T]: def apply()(using Type[T]): ToExpr[T] -object ToExprFactory: +private[quoted] trait LowPriorityToExprFactory: + given tupleConsToExprFactory: [H: ToExprFactory, T <: Tuple: ToExprFactory] => ToExprFactory[H *: T]: + def apply()(using Type[H *: T]): ToExpr[H *: T] = new ToExpr[H *: T]: + def apply(tup: H *: T)(using Quotes): Expr[H *: T] = summon[Type[H *: T]] match + case '[h *: t] => + given Type[H] = Type.of[h].asInstanceOf[Type[H]] + given Type[T] = Type.of[t].asInstanceOf[Type[T]] + val head = Expr(tup.head) + val tail = Expr(tup.tail) + '{ $head *: $tail } + +object ToExprFactory extends LowPriorityToExprFactory: inline def derived[T: Mirror.Of as m]: ToExprFactory[T] = inline m match case given Mirror.ProductOf[T] => derivedProduct[T](compiletime.summonAll[Tuple.Map[m.MirroredElemTypes, ToExprFactory]].toList.asInstanceOf[List[ToExprFactory[Any]]]) @@ -567,14 +578,3 @@ object ToExprFactory: given Type[T21] = Type.of[t21].asInstanceOf[Type[T21]] given Type[T22] = Type.of[t22].asInstanceOf[Type[T22]] '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}, ${Expr(tup._5)}, ${Expr(tup._6)}, ${Expr(tup._7)}, ${Expr(tup._8)}, ${Expr(tup._9)}, ${Expr(tup._10)}, ${Expr(tup._11)}, ${Expr(tup._12)}, ${Expr(tup._13)}, ${Expr(tup._14)}, ${Expr(tup._15)}, ${Expr(tup._16)}, ${Expr(tup._17)}, ${Expr(tup._18)}, ${Expr(tup._19)}, ${Expr(tup._20)}, ${Expr(tup._21)}, ${Expr(tup._22)}) } - - - given tupleConsToExprFactory: [H: ToExprFactory, T <: Tuple: ToExprFactory] => ToExprFactory[H *: T]: - def apply()(using Type[H *: T]): ToExpr[H *: T] = new ToExpr[H *: T]: - def apply(tup: H *: T)(using Quotes): Expr[H *: T] = summon[Type[H *: T]] match - case '[h *: t] => - given Type[H] = Type.of[h].asInstanceOf[Type[H]] - given Type[T] = Type.of[t].asInstanceOf[Type[T]] - val head = Expr(tup.head) - val tail = Expr(tup.tail) - '{ $head *: $tail }