Cleaner way to update nested structures

by

Funny that no one added lenses, since they were MADE for this kind of stuff. So, here is a CS background paper on it, here is a blog which touch briefly on lenses use in Scala, here is a lenses implementation for Scalaz and here is some code using it, which looks surprisingly like your question. And, to cut down on boiler plate, here’s a plugin that generate Scalaz lenses for case classes.

For bonus points, here’s another S.O. question which touches on lenses, and a paper by Tony Morris.

The big deal about lenses is that they are composable. So they are a bit cumbersome at first, but they keep gaining ground the more you use them. Also, they are great for testability, since you only need to test individual lenses, and can take for granted their composition.

So, based on an implementation provided at the end of this answer, here’s how you’d do it with lenses. First, declare lenses to change a zip code in an address, and an address in a person:

val addressZipCodeLens = Lens(
    get = (_: Address).zipCode,
    set = (addr: Address, zipCode: Int) => addr.copy(zipCode = zipCode))

val personAddressLens = Lens(
    get = (_: Person).address, 
    set = (p: Person, addr: Address) => p.copy(address = addr))

Now, compose them to get a lens that changes zipcode in a person:

val personZipCodeLens = personAddressLens andThen addressZipCodeLens

Finally, use that lens to change raj:

val updatedRaj = personZipCodeLens.set(raj, personZipCodeLens.get(raj) + 1)

Or, using some syntactic sugar:

val updatedRaj = personZipCodeLens.set(raj, personZipCodeLens(raj) + 1)

Or even:

val updatedRaj = personZipCodeLens.mod(raj, zip => zip + 1)

Here’s the simple implementation, taken from Scalaz, used for this example:

case class Lens[A,B](get: A => B, set: (A,B) => A) extends Function1[A,B] with Immutable {
  def apply(whole: A): B   = get(whole)
  def updated(whole: A, part: B): A = set(whole, part) // like on immutable maps
  def mod(a: A, f: B => B) = set(a, f(this(a)))
  def compose[C](that: Lens[C,A]) = Lens[C,B](
    c => this(that(c)),
    (c, b) => that.mod(c, set(_, b))
  )
  def andThen[C](that: Lens[B,C]) = that compose this
}

More Related Contents:

  1. Case objects vs Enumerations in Scala
  2. Case class equality in Apache Spark
  3. What is the difference between Scala’s case class and class?
  4. How to define schema for custom type in Spark SQL?
  5. How to override apply in a case class companion
  6. How to get around the Scala case class limit of 22 fields?
  7. Case class to map in Scala
  8. Mixing in a trait dynamically
  9. Easy idiomatic way to define Ordering for a simple case class
  10. Scala Macros: Making a Map out of fields of a class in Scala
  11. What is *so* wrong with case class inheritance?
  12. Scala case class inheritance
  13. Overload constructor for Scala’s Case Classes?
  14. Why is parameter in contravariant position?
  15. Should I use the final modifier when declaring case classes?
  16. Scala 2.10 reflection, how do I extract the field values from a case class, i.e. field list from case class
  17. “dynamically” creating case classes with macros
  18. How is this case class match pattern working?
  19. Combining two lists into one in Scala
  20. Why is Scala’s immutable Set not covariant in its type?
  21. Spark Scala: How to convert Dataframe[vector] to DataFrame[f1:Double, …, fn: Double)]
  22. Need clarification on Scala literal identifiers (backticks)
  23. Scala how can I count the number of occurrences in a list
  24. Spark losing println() on stdout
  25. Spark DataFrame: does groupBy after orderBy maintain that order?
  26. Spark UDAF with ArrayType as bufferSchema performance issues
  27. “new” keyword in Scala
  28. Reduce, fold or scan (Left/Right)?
  29. forall in Scala
  30. How do I run an sbt main class from the shell as normal command-line program?

Leave a Comment