Iterate over the fields of an object - scala

Question

I have a singleton objet with 100 different case classes. For example:
object Foo {
case class Bar1 {
...
}
...
case class Bar100 {
...
}
}
I would like to be able to iterate over each of the case class.
Something like getting all the case classes in a Seq and then being able to map over it.
(map with a polymorphic function for example)
Is it possible using reflection? If yes how? And what are the drawbacks of using reflection here over hard coding a sequence with all the case classes.

Answer 1

Foo.getClass.getDeclaredClasses gives you all the classes declared inside Foo. Because they are case classes, each also defines a companion object (which is also a class), so you'll need to filter them out:
Foo.getClass.getDeclaredClasses.filterNot(_.endsWith("$"))
Reflection is slow, but if you are only going to do it once (no reason to do it more than once, because you'll alway be getting the same result), it's not really an issue.
A bigger problem is that I can't really imagine a "polymorphic function" that would let you do anything useful with this information without some extreme hacking.

Answer 2

Fully parametric polymorphic functions exist in Scala 3. In Scala 2 there are no parametric polymorphic functions (and polymorphic values at all, only polymorphic methods) but there are ad-hoc polymorphic functions implemented normally with Shapeless.
I guess in Shapeless there is a type class (Generic/LabelledGeneric) for iterating case classes extending some sealed trait
case class Bar1() extends MyTrait
//...
case class Bar100() extends MyTrait
Scala how to derivate a type class on a trait
Use the lowest subtype in a typeclass?
Type class instance for case objects defined in sealed trait
Iteration over a sealed trait in Scala?
Getting subclasses of a sealed trait
Can I get a compile-time list of all of the case objects which derive from a sealed parent in Scala?
but not for iterating case classes nested into an object. So probably we'd need a macro (compile-time reflection) anyway, even using Shapeless
import scala.language.experimental.macros
// libraryDependencies += scalaOrganization.value % "scala-reflect" % scalaVersion.value
import scala.reflect.macros.whitebox
// libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.10"
import shapeless.HList
trait GetInnerCaseClasses[A] {
type Out <: HList
}
object GetInnerCaseClasses {
type Aux[A, Out0] = GetInnerCaseClasses[A] { type Out = Out0 }
implicit def mkGetInnerCaseClasses[A, Out <: HList]: Aux[A, Out] =
macro mkGetInnerCaseClassesImpl[A]
def mkGetInnerCaseClassesImpl[A: c.WeakTypeTag](c: whitebox.Context): c.Tree = {
import c.universe._
val A = weakTypeOf[A]
val caseClasses = A.decls.filter(s => s.isClass && s.asClass.isCaseClass)
val hList = caseClasses.foldRight[Tree](tq"_root_.shapeless.HNil")(
(s, hl) => tq"_root_.shapeless.::[$s, $hl]"
)
q"""
new GetInnerCaseClasses[$A] {
override type Out = $hList
}
"""
}
}
// in a different subproject
import shapeless.ops.hlist.{FillWith, Mapper}
import shapeless.{::, HList, HNil, Poly0, Poly1, Typeable, the}
object Foo {
case class Bar1()
// ...
case class Bar100()
}
implicitly[GetInnerCaseClasses.Aux[Foo.type, Bar1 :: Bar2 :: Bar100 :: HNil]] // compiles
val gicc = the[GetInnerCaseClasses[Foo.type]] // "the" is an advanced version of "implicitly" not damaging type refinements
implicitly[gicc.Out =:= (Bar1 :: Bar2 :: Bar100 :: HNil)] // compiles
// I'm just printing names of case classes, you should replace this with your actual iterating logic
object myPoly extends Poly1 {
implicit def cse[A <: Product : Typeable]: Case.Aux[A, Unit] =
at(_ => println(Typeable[A].describe))
}
object nullPoly extends Poly0 {
implicit def cse[A]: Case0[A] = at(null.asInstanceOf[A])
}
def myIterate[A <: Singleton] = new PartiallyAppliedMyIterate[A]
class PartiallyAppliedMyIterate[A <: Singleton] {
def apply[L <: HList]()(implicit
getInnerCaseClasses: GetInnerCaseClasses.Aux[A, L],
mapper: Mapper[myPoly.type, L],
fillWith: FillWith[nullPoly.type, L] // because type class GetInnerCaseClasses works only on type level
): Unit = mapper(fillWith())
}
myIterate[Foo.type]()
// Bar1
// ...
// Bar100