How to unwind an object based on deeply nested list fields in scala?

Simplified Scenario

Lets take a simplified example with 2 levels of nested fields in a case class.

Suppose I have a case class Person as shown below:

case class Address(
  name: String,
  zipCodes: List[String]
)

case class Person(
  name: String,
  address: List[Address]
)

Suppose I have an object for the above Person class as shown below:

val person1: Person = Person(
    name = "John",
    address = List(
      Address(
        name = "Address A",
        zipCodes = List("123","345")
      ),
      Address(
        name = "Address B",
        zipCodes = List("456","678")
      )
    )
  )

Now, I want to unwind this object person1 in such a way that I get following flattened list of tuples:

List(    
    (John, Address A, 123)
    (John, Address A, 345)
    (John, Address B, 456)
    (John, Address B, 678)
)

Now, in this simple scenario, what I could do to unwind is as follow:

person1.address.flatMap{
    address => address.zipCodes.map{
      zipCode =>
        (person1.name, address.name, zipCode)
    }

Question

In my real scenario, I can have n levels of nesting in the case class. So, it's not feasible for me to write n lines of flatMaps for each inner nested field to produce such tuple. Is there a generic(if possible), better, shorter yet functional way to achieve this in scala ?

You can write your example code using for:

for {
  address <- person1.address
  zipCode <- address.zipCodes
} yield {
  (person1.name, address.name, zipCode)
}

With this version it is easy to add as many levels of nesting as are required.

Another option is to give each nested class a flat method that creates the flattened version of the class using the flat method of the contained classes. This means that calling code does not need to know the nested structure, it just calls flat on the outer object. Or a typeclass could used if you can't change the original classes.

This question seems contradictory – on the one hand, you're saying that you can have n levels of nesting (where n is presumably not known at compile time), and you therefore can't write n levels of flatMaps. But on the other hand you're saying you want to return a tuple – but the length of the tuple in your example corresponds to the depth of nesting, meaning that n is the same as the length of the tuple and thus a compile-time constant.

Anyway, if you need arbitrary degrees of nesting, you need to use recursion.

case class RoseTree[A](
  a: A,
  children: List[RoseTree[A]]
)

def unnest[A](tree: RoseTree[A]): List[List[A]] =
  tree match {
    case RoseTree(a, Nil) =>
      List(List(a))
    case RoseTree(a, children) =>
      children.flatMap(x => unnest(x).map(a :: _))
  }

val example = 
  RoseTree("John", List(
    RoseTree("Address A", List(
      RoseTree("123", Nil),
      RoseTree("345", Nil))),
    RoseTree("Address B", List(
      RoseTree("456", Nil),
      RoseTree("678", Nil))))

assert(unnest(example) == List(
  List("John", "Address A", "123"),
  List("John", "Address A", "345"),
  List("John", "Address B", "456"),
  List("John", "Address B", "678")))