macro for listing typeclass instances for sealed hierarchy subtypes

Author: ghik

commons-core/src/main/scala/com/avsystem/commons/misc/SealedUtils.scala

@@ -12,6 +12,12 @@ object SealedUtils {
     */
   @explicitGenerics
   def caseObjectsFor[T]: List[T] = macro macros.misc.SealedMacros.caseObjectsFor[T]
+
+  /**
+    * Infers a list of instances of given typeclass `TC` for all non-abstract subtypes of a sealed hierarchy root `T`.
+    */
+  @explicitGenerics
+  def instancesFor[TC[_], T]: List[TC[_ <: T]] = macro macros.misc.SealedMacros.instancesFor[TC[_], T]
 }
 
 /**

commons-core/src/test/scala/com/avsystem/commons/misc/SealedEnumTest.scala

@@ -12,10 +12,16 @@ class SealedEnumTest extends FunSuite {
     case object Fourth extends SomeEnum
 
     val values: List[SomeEnum] = caseObjects
+    val classTags: List[ClassTag[_ <: SomeEnum]] = SealedUtils.instancesFor[ClassTag, SomeEnum]
   }
 
-  test("case objects listing test") {
+  test("case objects listing") {
     import SomeEnum._
     assert(values == List(First, Second, Third, Fourth))
   }
+
+  test("typeclass instance listing") {
+    import SomeEnum._
+    assert(classTags.map(_.runtimeClass) == List(First.getClass, Second.getClass, Third.getClass, Fourth.getClass))
+  }
 }

commons-macros/src/main/scala/com/avsystem/commons/macros/MacroCommons.scala

@@ -806,7 +806,9 @@ trait MacroCommons { bundle =>
       case _ => dtpe.typeSymbol
     }
     Option(tpeSym).filter(isSealedHierarchyRoot).map { sym =>
-      knownNonAbstractSubclasses(sym).toList.flatMap { subSym =>
+      val subclasses = knownNonAbstractSubclasses(sym).toList
+      val sortedSubclasses = if (tpeSym.pos != NoPosition) subclasses.sortBy(_.pos.point) else subclasses
+      sortedSubclasses.flatMap { subSym =>
         val undetparams = subSym.asType.typeParams
         val undetSubTpe = typeOfTypeSymbol(subSym.asType)
 

commons-macros/src/main/scala/com/avsystem/commons/macros/misc/SealedMacros.scala

@@ -9,9 +9,9 @@ class SealedMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx) {
 
   import c.universe._
 
-  val OrderedEnumType = getType(tq"$CommonsPkg.misc.OrderedEnum")
+  val OrderedEnumType: Type = getType(tq"$CommonsPkg.misc.OrderedEnum")
 
-  def caseObjectsFor[T: c.WeakTypeTag]: Tree = {
+  def caseObjectsFor[T: WeakTypeTag]: Tree = {
     val tpe = weakTypeOf[T]
     knownSubtypes(tpe).map { subtypes =>
       val objects = subtypes.map(subTpe => singleValueFor(subTpe)
@@ -20,4 +20,14 @@ class SealedMacros(ctx: blackbox.Context) extends AbstractMacroCommons(ctx) {
       if (tpe <:< OrderedEnumType) q"$result.sorted" else result
     }.getOrElse(abort(s"$tpe is not a sealed trait or class"))
   }
+
+  def instancesFor[TC: WeakTypeTag, T: WeakTypeTag]: Tree = {
+    val tpe = weakTypeOf[T]
+    def instanceTpe(forTpe: Type): Type = weakTypeOf[TC] match {
+      case TypeRef(pre, sym, Nil) => internal.typeRef(pre, sym, List(forTpe))
+      case _ => abort(s"expected type constructor")
+    }
+    val subtypes = knownSubtypes(tpe).getOrElse(abort(s"$tpe is not a sealed hierarchy root"))
+    q"${subtypes.map(st => q"""$ImplicitsObj.infer[${instanceTpe(st)}]("")""")}"
+  }
 }