diff --git a/library/src/scala/quoted/FromExpr.scala b/library/src/scala/quoted/FromExpr.scala index 40fea5b42258..ca7ff1ac00ec 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.publicInBinary /** A type class for types that can convert a `quoted.Expr[T]` to a `T`. * @@ -28,8 +29,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 { +object FromExpr extends LowPriorityFromExpr { /** Default implementation of `FromExpr[Boolean]` * - Transform `'{true}` into `Some(true)` @@ -110,14 +115,11 @@ object FromExpr { * - 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 - } - } + 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)` @@ -134,13 +136,11 @@ object FromExpr { * - 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 - } - } + 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 @@ -169,281 +169,232 @@ object FromExpr { * - 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 - } - } + 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) + + @publicInBinary private[quoted] final def Tuple1FromExpr[T1](using Type[T1], FromExpr[T1]): Tuple1FromExpr[T1] = new Tuple1FromExpr[T1] /** 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 - } - } + 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) + + @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[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 - } - } + 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) + + @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[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 - } - } + 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) + + @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[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 - } - } + 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) + + @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[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 - } - } + 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) + + @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[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 - } - } + 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) + + @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[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 - } - } + 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) + + @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[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 - } - } + 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) + + @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[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 - } - } + 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` */ - 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 - } - } + 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) + + @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[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 - } - } + 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) + + @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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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` */ - 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 - } - } + 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](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 - } - } + 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)` @@ -462,80 +413,63 @@ object FromExpr { * - 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 - } - } + 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](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 - } - } + 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, 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 - } - } + 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, 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 - } - } + 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, 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 - } - } + 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, 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 - } - } + 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/FromExprFactory.scala b/library/src/scala/quoted/FromExprFactory.scala new file mode 100644 index 000000000000..ce58825f9dac --- /dev/null +++ b/library/src/scala/quoted/FromExprFactory.scala @@ -0,0 +1,704 @@ +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]`. + * + * 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]) + + 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 + 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 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]] + + @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 + def apply()(using Type[T]): FromExpr[T] = new FromExpr[T]: + def unapply(x: Expr[T])(using quotes: Quotes): Option[T] = + import quotes.reflect.* + // 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] } + + /** Bridges any type that already has a plain `FromExpr` (e.g. `Int`, `String`) into `FromExprFactory`. */ + 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, 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]] + 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] => 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]] + 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] => 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]] + 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] => 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]] + 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, 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]] + 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] => 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]] + 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] => 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]] + 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, 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]] + 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, 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]] + 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] => 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]] + 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] => 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]] + 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, 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]] + 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, 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]] + 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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, 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]] => + 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 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 17bf89a71e50..9e0170b4fbda 100644 --- a/library/src/scala/quoted/ToExpr.scala +++ b/library/src/scala/quoted/ToExpr.scala @@ -2,6 +2,7 @@ package scala.quoted import language.experimental.captureChecking +import scala.annotation.publicInBinary import scala.reflect.ClassTag /** A type class for types that can convert a value of `T` into `quoted.Expr[T]` @@ -20,8 +21,17 @@ trait ToExpr[T] { } +// 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`. */ -object ToExpr { +object ToExpr extends LowPriorityToExpr { // IMPORTANT Keep in sync with tests/run-staging/liftables.scala @@ -97,16 +107,18 @@ object ToExpr { } /** 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]])}) } - } + 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]]`. */ - 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]])}) } - } + 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) + + @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 { @@ -171,16 +183,18 @@ object ToExpr { } /** 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)) - } + 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]]`. */ - 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)) - } + 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) + + @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,30 +203,32 @@ object ToExpr { } /** 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)}*) } - } + 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]]`. */ - 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)}*) } - } + 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]]`. */ - 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) - } - } + 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) + + @publicInBinary private[quoted] final def OptionToExpr[T: {Type, ToExpr}]: OptionToExpr[T] = new OptionToExpr[T] /** Default implementation of `ToExpr[Some[T]]`. */ - given SomeToExpr[T: Type: ToExpr]: ToExpr[Some[T]] with { + class SomeToExpr[T: {Type, ToExpr}] @publicInBinary private[quoted] extends ToExpr[Some[T]]: def apply(x: Some[T])(using Quotes): Expr[Some[T]] = - '{ Some[T](${Expr(x.get)}) } - } + ToExprFactory.someToExprFactory[T].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 { @@ -221,23 +237,25 @@ object ToExpr { } /** 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) - } + 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) + + @publicInBinary private[quoted] final def EitherToExpr[L: {Type, ToExpr}, R: {Type, ToExpr}]: EitherToExpr[L, R] = new EitherToExpr[L, R] /** Default implementation of `ToExpr[Left[L, R]]`. */ - given LeftToExpr[L: Type: ToExpr, R: Type]: ToExpr[Left[L, R]] with { + 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]] = - '{ Left[L, R](${Expr(x.value)}) } - } + 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]]`. */ - given RightToExpr[L: Type, R: Type: ToExpr]: ToExpr[Right[L, R]] with { + 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]] = - '{ Right[L, R](${Expr(x.value)}) } - } + 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 { @@ -246,180 +264,165 @@ object ToExpr { } /** 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)}) } - } + 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]]`. */ - 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)}) } - } + 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]]`. */ - 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)}) } - } + 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]]`. */ - 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)}) } - } + 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]]`. */ - 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)}) } - } - } + 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]]`. */ - 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)}) } - } - } + 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]]`. */ - 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)}) } - } - } + 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]]`. */ - 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)}) } - } - } + 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]]`. */ - 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)}) } - } - } + 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]]`. */ - 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)}) } - } - } + 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]]`. */ - 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)}) } - } - } + 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]]`. */ - 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)}) } - } - } + 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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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)}) } - } - } + 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) + + @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[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 } - } + 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) + + @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 { diff --git a/library/src/scala/quoted/ToExprFactory.scala b/library/src/scala/quoted/ToExprFactory.scala new file mode 100644 index 000000000000..2acccf90578d --- /dev/null +++ b/library/src/scala/quoted/ToExprFactory.scala @@ -0,0 +1,580 @@ +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 `ToExpr[T]`. + * + * `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] + +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]]]) + case given Mirror.SumOf[T] => + 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 + 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]] + 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 + def apply()(using Type[T]): ToExpr[T] = new ToExpr[T]: + def apply(x: T)(using quotes: Quotes): Expr[T] = + import quotes.reflect.* + val idx = m.ordinal(x) + // 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]: + 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, 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 elemExprs = Expr.ofSeq(arr.toSeq.map(Expr(_))) + '{ Array[T]($elemExprs*)(using ${Expr(ct)}) } + + 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]] + Expr.ofSeq(xs.map(Expr(_))) + + 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]] + Expr.ofList(xs.map(Expr(_))) + + 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 elemExprs = Expr.ofSeq(xs.toSeq.map(Expr(_))) + '{ Set($elemExprs*) } + + 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 pairs = m.toSeq.map((k, v) => '{ (${Expr(k)}, ${Expr(v)}) }) + '{ Map(${Expr.ofSeq(pairs)}*) } + + 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]] + x match + case Some(v) => '{ Some[T](${Expr(v)}) } + case None => '{ None } + + 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]] + '{ Some[T](${Expr(x.get)}) } + + 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]] + x match + case scala.util.Left(v) => '{ Left[L, R](${Expr(v)}) } + case scala.util.Right(v) => '{ Right[L, R](${Expr(v)}) } + + 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]] + '{ Left[L, R](${Expr(x.value)}) } + + 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]] + '{ 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] => 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]] + '{ Tuple1(${Expr(tup._1)}) } + + + 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]] + '{ (${Expr(tup._1)}, ${Expr(tup._2)}) } + + + 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]] + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}) } + + + 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]] => + 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]] + '{ (${Expr(tup._1)}, ${Expr(tup._2)}, ${Expr(tup._3)}, ${Expr(tup._4)}) } + + + 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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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]] => + 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]] + '{ (${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)}) } 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..165eaed6c43e --- /dev/null +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Macro_1.scala @@ -0,0 +1,304 @@ +import scala.quoted.* + +// Plain product, primitives +case class Point(x: Int, y: Int) derives ToExprFactory, FromExprFactory + +// Product, mixed field kinds +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 ToExprFactory, FromExprFactory +case class Seconds(value: Int) derives ToExprFactory, FromExprFactory + +// `derived` on a tuple type directly +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 FromExprFactory +object Namespace: + case class Person(name: String, address: Address) derives FromExprFactory + +// Three levels of nesting +case class Company(hq: Address, ceo: Namespace.Person) derives FromExprFactory + +// Singleton (case object) +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: + 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 ToExprFactory, FromExprFactory: + case Red, Green + case Custom(hex: String) + +// Product with a sum-typed field +case class Container(name: String, shape: Shape) derives ToExprFactory, FromExprFactory + +// Zero-arg product (not a singleton) +case class Blank() derives ToExprFactory, FromExprFactory + +// Generic sum (explicit bound on the trait; cases auto-derived) +sealed trait Result[+A] derives FromExprFactory, ToExprFactory +object Result: + case class Ok[A](value: A) extends Result[A] + case object Fail extends Result[Nothing] + +// Nested sum hierarchy, two levels of dispatch +sealed trait Vehicle derives ToExprFactory, FromExprFactory +object Vehicle: + sealed trait Motorized extends Vehicle + object Motorized: + case class Car(wheels: Int) extends Motorized + case class Motorcycle(cc: Int) extends Motorized + case class Bicycle(gears: Int) extends Vehicle + +// Recursive sum: a case's own field is the enclosing type +enum Arith derives ToExprFactory, FromExprFactory: + case Lit(n: Int) + case Add(l: Arith, r: Arith) + case Neg(e: Arith) + +// 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, + f21: Int, f22: Int, f23: Int, f24: Int, f25: Int +) derives ToExprFactory, FromExprFactory + +object Macro: + // Constructor-call recognition: `apply` and `new` + 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 } + + inline def matchVehicleCar: Boolean = ${ Macro.matchVehicleCarImpl } + inline def matchVehicleMotorcycle: Boolean = ${ Macro.matchVehicleMotorcycleImpl } + inline def matchVehicleBicycle: Boolean = ${ Macro.matchVehicleBicycleImpl } + // 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 } + + // `Block(Nil, ...)` node unwrapping + inline def matchBracedPoint: Boolean = ${ Macro.matchBracedPointImpl } + + // Not a constructor call + inline def nonMatchingIsNone: Boolean = ${ Macro.nonMatchingIsNoneImpl } + // Same arity, wrong type + inline def wrongTypeIsNone: Boolean = ${ Macro.wrongTypeIsNoneImpl } + // Wrong sum variant + inline def wrongSumVariantIsNone: Boolean = ${ Macro.wrongSumVariantIsNoneImpl } + // Wrong arity + inline def wrongArityIsNone: Boolean = ${ Macro.wrongArityIsNoneImpl } + // Arity > 22, documented limitation + inline def roundTripBig25IsNone: Boolean = ${ Macro.roundTripBig25IsNoneImpl } + // Wrong mirror, same arity/field type + inline def wrongMirrorIsNone: Boolean = ${ Macro.wrongMirrorIsNoneImpl } + + // `derived` on a tuple type directly + inline def matchTuple2: Boolean = ${ Macro.matchTuple2Impl } + inline def roundTripTuple5: Boolean = ${ Macro.roundTripTuple5Impl } + + // ToExpr -> FromExpr round trip, all cases above + inline def roundTrips: Boolean = ${ Macro.roundTripsImpl } + + // 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 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)) + 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 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] = + 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]]) + + 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)) + + 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] = + given FromExpr[Shape.Rect] = FromExprFactory.derived[Shape.Rect].apply() + val e: Expr[Shape.Circle] = '{ Shape.Circle(1.0) } + checkNone(e.asInstanceOf[Expr[Shape.Rect]]) + + def wrongArityIsNoneImpl(using Quotes): Expr[Boolean] = + 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) + 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 as fe}](original: T): Boolean = + fe.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")) + && 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))))) + ) + + 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 new file mode 100644 index 000000000000..4bc8b15d0f38 --- /dev/null +++ b/tests/run-macros/quoted-FromExpr-mirror-derivation/Test_2.scala @@ -0,0 +1,39 @@ +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.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") + 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") + 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 new file mode 100644 index 000000000000..8ff228418c26 --- /dev/null +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Macro_1.scala @@ -0,0 +1,122 @@ +import scala.quoted.* + +// Plain product, primitives +case class Point(x: Int, y: Int) derives ToExprFactory + +// Nested products, cross-object +case class Address(city: String, zip: Int) derives ToExprFactory +object Namespace: + case class Person(name: String, address: Address) derives ToExprFactory + +// Singleton (case object) +case object Singleton derives ToExprFactory + +// Generic product (needs an explicit Type/instance bound) +case class Box[A](value: A) derives ToExprFactory + +// Product, mixed field kinds +case class Mixed(name: String, flag: Boolean, ratio: Double) derives ToExprFactory + +// 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 +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 ToExprFactory: + case Red, Green + case Custom(hex: String) + +// Product with a sum-typed field +case class Container(name: String, shape: Shape) derives ToExprFactory + +// Zero-arg product (not a singleton) +case class Blank() derives ToExprFactory + +// Generic sum (explicit bound on the trait; cases auto-derived) +sealed trait Result[+A] derives ToExprFactory +object Result: + case class Ok[A](value: A) extends Result[A] + case object Fail extends Result[Nothing] + +// Non-case singleton, lifted via valueOf[T] (no `derives`) +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 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 } + 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: 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)) + 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 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() + 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..441c97c1543a --- /dev/null +++ b/tests/run-macros/quoted-ToExpr-mirror-derivation/Test_2.scala @@ -0,0 +1,30 @@ +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.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) + 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)