Converting nested case classes to nested Maps using Shapeless

by

Any time you want to perform an operation like flatMap on an HList whose type isn’t statically known, you’ll need to provide evidence (in the form of an implicit parameter) that the operation is actually available for that type. This is why the compiler is complaining about missing FlatMapper instances—it doesn’t know how to flatMap(identity) over an arbitrary HList without them.

A cleaner way to accomplish this kind of thing would be to define a custom type class. Shapeless already provides a ToMap type class for records, and we can take it as a starting point, although it doesn’t provide exactly what you’re looking for (it doesn’t work recursively on nested case classes).

We can write something like the following:

import shapeless._, labelled.FieldType, record._

trait ToMapRec[L <: HList] { def apply(l: L): Map[String, Any] }

Now we need to provide instances for three cases. The first case is the base case—the empty record—and it’s handled by hnilToMapRec below.

The second case is the case where we know how to convert the tail of the record, and we know that the head is something that we can also recursively convert (hconsToMapRec0 here).

The final case is similar, but for heads that don’t have ToMapRec instances (hconsToMapRec1). Note that we need to use a LowPriority trait to make sure that this instance is prioritized properly with respect to hconsToMapRec0—if we didn’t, the two would have the same priority and we’d get errors about ambiguous instances.

trait LowPriorityToMapRec {
  implicit def hconsToMapRec1[K <: Symbol, V, T <: HList](implicit
    wit: Witness.Aux[K],
    tmrT: ToMapRec[T]
  ): ToMapRec[FieldType[K, V] :: T] = new ToMapRec[FieldType[K, V] :: T] {
    def apply(l: FieldType[K, V] :: T): Map[String, Any] =
      tmrT(l.tail) + (wit.value.name -> l.head)
  }
}

object ToMapRec extends LowPriorityToMapRec {
  implicit val hnilToMapRec: ToMapRec[HNil] = new ToMapRec[HNil] {
    def apply(l: HNil): Map[String, Any] = Map.empty
  }

  implicit def hconsToMapRec0[K <: Symbol, V, R <: HList, T <: HList](implicit
    wit: Witness.Aux[K],
    gen: LabelledGeneric.Aux[V, R],
    tmrH: ToMapRec[R],
    tmrT: ToMapRec[T]
  ): ToMapRec[FieldType[K, V] :: T] = new ToMapRec[FieldType[K, V] :: T] {
    def apply(l: FieldType[K, V] :: T): Map[String, Any] =
      tmrT(l.tail) + (wit.value.name -> tmrH(gen.to(l.head)))
  }
}

Lastly we provide some syntax for convenience:

implicit class ToMapRecOps[A](val a: A) extends AnyVal {
  def toMapRec[L <: HList](implicit
    gen: LabelledGeneric.Aux[A, L],
    tmr: ToMapRec[L]
  ): Map[String, Any] = tmr(gen.to(a))
}

And then we can demonstrate that it works:

scala> p.toMapRec
res0: Map[String,Any] = Map(address -> Map(zip -> 10000, street -> Jefferson st), name -> Tom)

Note that this won’t work for types where the nested case classes are in a list, tuple, etc., but you could extend it to those cases pretty straightforwardly.

More Related Contents:

  1. Weird behavior trying to convert case classes to heterogeneous lists recursively with Shapeless
  2. Why is the Aux technique required for type-level computations?
  3. Any reason why scala does not explicitly support dependent types?
  4. Use functional combinators on Scala Tuples?
  5. Are HLists nothing more than a convoluted way of writing tuples?
  6. Can’t prove that singleton types are singleton types while generating type class instance
  7. Unable to map on HList
  8. Limits of Nat type in Shapeless
  9. Converting Map[String,Any] to a case class using Shapeless
  10. Understanding the Aux pattern in Scala Type System
  11. Getting subclasses of a sealed trait
  12. How to define “type disjunction” (union types)?
  13. How to define partitioning of DataFrame?
  14. In Scala, what is an “early initializer”?
  15. Case class equality in Apache Spark
  16. What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?
  17. Dropping a nested column from Spark DataFrame
  18. How to model type-safe enum types?
  19. Filling gaps in timeseries Spark
  20. How to create a TypeTag manually?
  21. Implicit keyword before a parameter in anonymous function in Scala
  22. What does a lazy val do?
  23. How to clone a case class instance and change just one field in Scala?
  24. How to use third party libraries with Scala REPL?
  25. How do I pattern match arrays in Scala?
  26. Applying an argument list to curried function using foldLeft in Scala
  27. How can I convert immutable.Map to mutable.Map in Scala?
  28. Should I use the final modifier when declaring case classes?
  29. Is there a simple example of how to generate verilog from Chisel3 module?
  30. Run a scala code jar appear NoSuchMethodError:scala.Predef$.refArrayOps

Leave a Comment