Scala case classes and recursive reflection

Question

Given 2 Scala case classes

case class Bar(x: Int)
case class Foo(b: Bar, z: Double)

I have a piece of code that prints the types of Foo fields using reflection:

import scala.reflect.runtime.universe._
def f[T: TypeTag] = typeOf[T].members.filter(!_.isMethod)

and I call it like f[Foo] and f[Bar]. Calling the former returns a List[Type] as [Bar, Double].

How can I call f on the first element of the list? Equivalently, how can I print types recursively when Foo has a custom class Bar? Equivalently how can I get from Bar as Type a Bar.type?

Many thanks

Answer 1

You don't actually need the type variable T in f. You can define it like this (as Dima suggested in the comments):

def f(t: Type) =
  t.members.filter(!_.isMethod).map(_.typeSignature)

To use this to recursively print a type:

def printTypesRecursive(t: Type, prefix: String = ""): Unit = {
  println(prefix + t)
  f(t).foreach(printTypesRecursive(_, prefix + " "))
}

printTypesRecursive(typeOf[Foo])

Output:

Foo
 Double
 Bar
  Int

Answer 2

Equivalently how can I get from Bar as Type a Bar.type?

Bar.type is the type of companion object

Class companion object vs. case class itself

I need something like f[f[Foo].head]

I guess you have here some confusion between compile-time and runtime

Runtime vs. Compile time

You can call

def f[T: TypeTag] = typeOf[T].members.filter(!_.isMethod)

f[Foo]

//Scope{
//  private[this] val z: <?>;
//  private[this] val b: <?>
//}

if you know type T statically i.e. at compile time (earlier).

You can call

def f_dyn(tpe: Type) = tpe.members.filter(!_.isMethod)

f_dyn(typeOf[Foo])

//Scope{
//  private[this] val z: <?>;
//  private[this] val b: <?>
//}

if you know type tpe dynamically i.e. at runtime (later).

You can express f via f_dyn

def f[T: TypeTag] = f_dyn(typeOf[T])

def f_dyn(tpe: Type) = tpe.members.filter(!_.isMethod)

If you want to iterate the method (apply it recursively) then it should return something like it accepts, i.e. now this is types rather than symbols, so you need to add somewhere something like .typeSignature, .asMethod.returnType, .asType.toType. Also maybe now you're more interested in .decls rather than .members since you are not looking for inherited members. Also .decls returns field symbols in correct order on contrary to .members. Finally let it be better List[...] rather than raw Scope (.toList)

def f[T: TypeTag]: List[Type] = f_dyn(typeOf[T])

def f_dyn(tpe: Type): List[Type] =
  tpe.decls.filter(!_.isMethod).map(_.typeSignature).toList

f_dyn(f[Foo].head)             // List(Int)
f_dyn(f_dyn(typeOf[Foo]).head) // List(Int)

You can iterate f_dyn

f_dyn(typeOf[Foo])                              // List(Bar, Double)
f_dyn(typeOf[Foo]).map(f_dyn)                   // List(List(Int), List())
f_dyn(typeOf[Foo]).map(f_dyn).map(_.map(f_dyn)) // List(List(List()), List())

If you really want to iterate f rather than f_dyn then the complication is that you can call f[T] for the second time only on a statically known type T but you have the type that is the result of the first call only at runtime, you don't have it at compile time. In principle you can use runtime compilation (creating new compile time inside runtime) although this can work slower than ordinary reflection and doesn't seem needed now

import scala.reflect.runtime.{currentMirror => rm}
import scala.tools.reflect.ToolBox // libraryDependencies += scalaOrganization.value % "scala-compiler" % scalaVersion.value
val tb = rm.mkToolBox()

// suppose f is defined in object App 
tb.eval(q"App.f[${f[Foo].head}]")  // List(Int)

tb.eval(q"""
  import App._
  f[${f[Foo].head}]
""")
// List(Int)

Now all the classes Foo, Bar... are defined at compile time so it would make sense to use compile-time reflection (macros) rather than runtime reflection

Getting Case Class definition which points to another Case Class

import scala.language.experimental.macros
import scala.reflect.macros.blackbox

def f[T]: List[String] = macro Macros.f_impl[T]
def f1[T]: List[List[String]] = macro Macros.f1_impl[T]
def f2[T]: List[List[List[String]]] = macro Macros.f2_impl[T]

class Macros(val c: blackbox.Context) {
  import c.universe._

  def f_dyn(tpe: Type): List[Type] =
    tpe.decls.filter(!_.isMethod).map(_.typeSignature).toList

  val ListObj = q"_root_.scala.List"
  val ListT   = tq"_root_.scala.List"
  val StringT = tq"_root_.scala.Predef.String"

  def f_impl[T: WeakTypeTag]: Tree = {
    val types: List[Type] = f_dyn(weakTypeOf[T])
    val typeStrings: List[String] = types.map(_.toString)
    q"$ListObj.apply[$StringT](..$typeStrings)"
  }

  def f1_impl[T: WeakTypeTag]: Tree = {
    val types: List[List[Type]] = f_dyn(weakTypeOf[T]).map(f_dyn)
    val typeStrings: List[List[String]] = types.map(_.map(_.toString))
    q"$ListObj.apply[$ListT[$StringT]](..$typeStrings)"
  }

  def f2_impl[T: WeakTypeTag]: Tree = {
    val types: List[List[List[Type]]] =
      f_dyn(weakTypeOf[T]).map(f_dyn).map(_.map(f_dyn))
    val typeStrings: List[List[List[String]]] = types.map(_.map(_.map(_.toString)))
    q"$ListObj.apply[$ListT[$ListT[$StringT]]](..$typeStrings)"
  }
}

// in a different subproject

f[Foo]
//scalac: _root_.scala.List.apply[_root_.scala.Predef.String]("Bar", "Double")

f1[Foo]
//scalac: _root_.scala.List.apply[_root_.scala.List[_root_.scala.Predef.String]](scala.collection.immutable.List("Int"), scala.collection.immutable.List())

f2[Foo]
//scalac: _root_.scala.List.apply[_root_.scala.List[_root_.scala.List[_root_.scala.Predef.String]]](scala.collection.immutable.List(scala.collection.immutable.List()), scala.collection.immutable.List())

The runtime of macros (when they are expanded) is the compile time of main code.

Do macros support annotations too? like can I access my case class annotations with macros? with runtime reflection , i would do symbolOf[Foo].asClass.annotations

Yes, surely.

def foo[T]: Unit = macro fooImpl[T]
def fooImpl[T: c.WeakTypeTag](c: blackbox.Context): c.Tree = {
  import c.universe._
  println(symbolOf[T].asClass.annotations)
  q"()"
}

class myAnnot extends StaticAnnotation

@myAnnot
case class Foo(b: Bar, z: Double)

symbolOf[Foo].asClass.annotations // at runtime: List(myAnnot)

foo[Foo]
// at compile time with scalacOptions += "-Ymacro-debug-lite":
// scalac: List(myAnnot)

One more option to perform compile-time calculations is to use one of libraries encapsulating work with macros e.g. Shapeless

// libraryDependencies += "com.chuusai" %% "shapeless" % "2.3.10"
import shapeless.{::, DepFn0, DepFn1, HList, HNil, Generic, Poly0, Poly1, Typeable, poly}

trait DeepGeneric[T <: Product] {
  type Repr <: HList
  def to(t: T): Repr
  def from(r: Repr): T
}

object DeepGeneric {
  type Aux[T <: Product, Repr0 <: HList] = DeepGeneric[T] {type Repr = Repr0}
  def instance[T <: Product, Repr0 <: HList](f: T => Repr0, g: Repr0 => T): Aux[T, Repr0] = new DeepGeneric[T] {
    override type Repr = Repr0
    override def to(t: T): Repr = f(t)
    override def from(r: Repr): T = g(r)
  }

  implicit def deepGeneric[A <: Product, L <: HList, L1 <: HList](implicit
    generic: Generic.Aux[A, L],
    hListDeepGeneric: HListDeepGeneric.Aux[L, L1]
  ): Aux[A, L1] = instance(a => hListDeepGeneric.to(generic.to(a)), l1 => generic.from(hListDeepGeneric.from(l1)))
}

trait HListDeepGeneric[T <: HList] {
  type Repr <: HList
  def to(t: T): Repr
  def from(r: Repr): T
}

trait LowPriorityHListDeepGeneric {
  type Aux[T <: HList, Repr0 <: HList] = HListDeepGeneric[T] {type Repr = Repr0}
  def instance[T <: HList, Repr0 <: HList](f: T => Repr0, g: Repr0 => T): Aux[T, Repr0] = new HListDeepGeneric[T] {
    override type Repr = Repr0
    override def to(t: T): Repr = f(t)
    override def from(r: Repr): T = g(r)
  }

  implicit def headNotCaseClass[H, T <: HList, T_hListDeepGen <: HList](implicit
    tailHListDeepGeneric: HListDeepGeneric.Aux[T, T_hListDeepGen]
  ): Aux[H :: T, H :: T_hListDeepGen] = instance({
    case h :: t => h :: tailHListDeepGeneric.to(t)
  }, {
    case h :: t => h :: tailHListDeepGeneric.from(t)
  })
}

object HListDeepGeneric extends LowPriorityHListDeepGeneric {
  implicit val hNil: Aux[HNil, HNil] = instance(identity, identity)

  implicit def headCaseClass[H <: Product, T <: HList, H_deepGen <: HList, T_hListDeepGen <: HList](implicit
    headDeepGeneric: DeepGeneric.Aux[H, H_deepGen],
    tailHListDeepGeneric: HListDeepGeneric.Aux[T, T_hListDeepGen]
  ): Aux[H :: T, H_deepGen :: T_hListDeepGen] = instance({
    case h :: t => headDeepGeneric.to(h) :: tailHListDeepGeneric.to(t)
  }, {
    case h :: t => headDeepGeneric.from(h) :: tailHListDeepGeneric.from(t)
  })
}


trait DeepMapper[P <: Poly1, In <: HList] extends DepFn1[In] {
  type Out <: HList
}

trait LowPriorityDeepMapper {
  type Aux[P <: Poly1, In <: HList, Out0 <: HList] = DeepMapper[P, In] {type Out = Out0}
  def instance[P <: Poly1, In <: HList, Out0 <: HList](f: In => Out0): Aux[P, In, Out0] = new DeepMapper[P, In] {
    override type Out = Out0
    override def apply(t: In): Out = f(t)
  }

  implicit def headNotHList[P <: Poly1, H, T <: HList](implicit
    headCase: poly.Case1[P, H],
    tailDeepMapper: DeepMapper[P, T]
  ): Aux[P, H :: T, headCase.Result :: tailDeepMapper.Out] =
    instance(l => headCase(l.head) :: tailDeepMapper(l.tail))
}

object DeepMapper extends LowPriorityDeepMapper {
  implicit def hNil[P <: Poly1]: Aux[P, HNil, HNil] = instance(_ => HNil)

// implicit def headHList[P <: Poly1, H <: HList, H_deepMap <: HList, T <: HList](implicit
//   headDeepMapper: DeepMapper.Aux[P, H, H_deepMap],
//   headCase: poly.Case1[P, H_deepMap], // apply poly one more time
//   tailDeepMapper: DeepMapper[P, T]
// ): Aux[P, H :: T, headCase.Result :: tailDeepMapper.Out] =
//   instance(l => headCase(headDeepMapper(l.head)) :: tailDeepMapper(l.tail))

  implicit def headHList[P <: Poly1, H <: HList, T <: HList](implicit
    headDeepMapper: DeepMapper[P, H], // don't apply poly one more time
    tailDeepMapper: DeepMapper[P, T]
  ): Aux[P, H :: T, headDeepMapper.Out :: tailDeepMapper.Out] =
    instance(l => headDeepMapper(l.head) :: tailDeepMapper(l.tail))
}

trait DeepFillWith[P <: Poly0, L <: HList] extends DepFn0 {
  type Out = L
}

trait LowPriorityDeepFillWith {
  def apply[P <: Poly0, L <: HList](implicit deepFillWith: DeepFillWith[P, L]): DeepFillWith[P, L] = deepFillWith
  def instance[P <: Poly0, L <: HList](f: => L): DeepFillWith[P, L] = new DeepFillWith[P, L] {
    override def apply(): L = f
  }

  implicit def headNotHList[P <: Poly0, H, T <: HList](implicit
    headCase: poly.Case0.Aux[P, H],
    tailDeepFillWith: DeepFillWith[P, T]
  ): DeepFillWith[P, H :: T] =
    instance(headCase() :: tailDeepFillWith())
}

object DeepFillWith extends LowPriorityDeepFillWith {
  implicit def hNil[P <: Poly0]: DeepFillWith[P, HNil] = instance(HNil)

  implicit def headHList[P <: Poly0, H <: HList, T <: HList](implicit
    headDeepFillWith: DeepFillWith[P, H],
    tailDeepFillWith: DeepFillWith[P, T]
  ): DeepFillWith[P, H :: T] =
    instance(headDeepFillWith() :: tailDeepFillWith())
}

// needed if DeepMapper "applies poly one more time",
// e.g. for field NAMES and types (via DeepLabelledGeneric), not just types (via DeepGeneric)
//  trait LowPriorityTypeablePoly extends Poly1 {
//    implicit def notHListCase[V](implicit typeable: Typeable[V]): Case.Aux[V, String] =
//      at(_ => typeable.describe)
//  }
//
//  object typeablePoly extends LowPriorityTypeablePoly {
//    implicit def hListCase[V <: HList]: Case.Aux[V, V] = at(identity)
//  }

object typeablePoly extends Poly1 {
  implicit def cse[A](implicit typeable: Typeable[A]): Case.Aux[A, String] =
    at(_ => typeable.describe)
}

object nullPoly extends Poly0 {
  implicit def cse[A]: Case0[A] = at(null.asInstanceOf[A])
}

def classFieldTypes[T <: Product] = new PartiallyApplied[T]

class PartiallyApplied[T <: Product] {
  def apply[L <: HList]()(implicit
    deepGeneric: DeepGeneric.Aux[T, L],
    deepFillWith: DeepFillWith[nullPoly.type, L],
    deepMapper: DeepMapper[typeablePoly.type, L],
  ): deepMapper.Out = deepMapper(deepFillWith())
}

classFieldTypes[Bar]() // Int :: HNil
classFieldTypes[Foo]() // (Int :: HNil) :: Double :: HNil

Generic/LabelledGeneric/DeepGeneric, Mapper/DeepMapper, FillWith/DeepFillWith, Typeable are type classes.

lets say for each Type I want the code to behave differently, if Double do x, if Int do y.

You can use types comparisons t =:= typeOf[Double], t <:< typeOf[Double] if you use runtime/compile-time reflection or you can keep using type classes and polymorphic functions

trait MyTypeclass[T] {
  def apply(): Unit
}
object MyTypeclass {
  implicit val double: MyTypeclass[Double] = () => println("do x")
  implicit val int: MyTypeclass[Int] = () => println("do y")

  implicit def caseClass[T <: Product, L <: HList](implicit
    deepGeneric: DeepGeneric.Aux[T, L],
    deepFillWith: DeepFillWith[nullPoly.type, L],
    deepMapper: DeepMapper[myPoly.type, L]
  ): MyTypeclass[T] = () => deepMapper(deepFillWith())
}

object myPoly extends Poly1 {
  implicit def cse[T: MyTypeclass]: Case.Aux[T, Unit] = at(_ => foo)
}

def foo[T](implicit tc: MyTypeclass[T]): Unit = tc()

foo[Int]
// do y
foo[Double]
// do x
foo[Foo]
// do y
// do x
foo[Bar]
// do y

Shapeless is also capable of handling annotations

import shapeless.Annotation

implicitly[Annotation[myAnnot, Foo]].apply() // myAnnot@1a3869f4