Implement full example with Mirrors of Sums and Products

Author: biboudis

tests/run-macros/i8007.check

@@ -7,3 +7,9 @@ true
 
 false
 
+true
+
+true
+
+false
+

tests/run-macros/i8007/Macro_3.scala

@@ -27,14 +27,19 @@ object Eq {
 
   def summonAll[T](t: Type[T])(given qctx: QuoteContext): List[Expr[Eq[_]]] = t match {
     case '[$tpe *: $tpes] =>
-      println(tpe.show)
-      summonExpr(given '[Eq[$tpe]]).get :: summonAll(tpes)
+      val eqInstance = summonExpr(given '[Eq[$tpe]]) match {
+        case Some(ev) => ev
+        case None => derived(given tpe, qctx)
+      }
+      eqInstance :: summonAll(tpes)
     case '[Unit] => Nil
   }
 
-  def derived[T: Type](ev: Expr[Mirror.Of[T]])(given qctx: QuoteContext): Expr[Eq[T]] = {
+  given derived[T: Type](given qctx: QuoteContext): Expr[Eq[T]] = {
     import qctx.tasty.{_, given}
 
+    val ev: Expr[Mirror.Of[T]] = summonExpr(given '[Mirror.Of[T]]).get
+
     ev match {
       case '{ $m: Mirror.ProductOf[T] { type MirroredElemTypes = $elementTypes }} =>
         val elemInstances = summonAll(elementTypes)
@@ -71,20 +76,7 @@ object Eq {
 }
 
 object Macro3 {
+  inline def [T](x: =>T) === (y: =>T)(given eq: Eq[T]): Boolean = eq.eqv(x, y)
 
-
-
-  inline def test3[T](value: =>T, value2: =>T): Boolean = ${ test3Impl('value, 'value2) }
-
-  def test3Impl[T: Type](value: Expr[T], value2: Expr[T])(given qctx: QuoteContext): Expr[Boolean] = {
-    import qctx.tasty.{_, given}
-
-    val mirrorTpe = '[Mirror.Of[T]]
-    val mirrorExpr = summonExpr(given mirrorTpe).get
-    val derivedInstance = Eq.derived(mirrorExpr)
-
-    '{
-      $derivedInstance.eqv($value, $value2)
-    }
-  }
+  implicit inline def eqGen[T]: Eq[T] = ${ Eq.derived[T] }
 }

tests/run-macros/i8007/Test_4.scala

@@ -1,17 +1,18 @@
 import Macro1._
 import Macro2._
 import Macro3._
-import scala.deriving._
+import Macro3.eqGen
 
 case class Person(name: String, age: Int)
 
-enum Opt[+T] derives Eq {
+enum Opt[+T] {
   case Sm(t: T)
   case Nn
 }
 
 @main def Test() = {
   import Opt._
+  import Eq.{given, _}
 
   val t1 = test1(Person("Test", 23))
   println(t1)
@@ -21,15 +22,23 @@ enum Opt[+T] derives Eq {
   println(t2)
   println
 
-  val t3 = test3(Person("Test", 23), Person("Test", 23))
+  val t3 = Person("Test", 23) === Person("Test", 23)
   println(t3) // true
   println
 
-  val t4 = test3(Person("Test", 23), Person("Test", 24))
+  val t4 = Person("Test", 23) === Person("Test", 24)
   println(t4) // false
   println
 
-  val t5 = test3(Sm(Person("Test", 23)), Sm(Person("Test", 23)))
+  val t5 = Sm(23) === Sm(23)
   println(t5) // true
   println
+
+  val t6 = Sm(Person("Test", 23)) === Sm(Person("Test", 23))
+  println(t6) // true
+  println
+
+  val t7 = Sm(Person("Test", 23)) === Sm(Person("Test", 24))
+  println(t7) // false
+  println
 }