How to get around the Scala case class limit of 22 fields?

by

More recently (Oct 2016, six years after the OP), the blog post “Scala and 22” from Richard Dallaway explores that limit:

Back in 2014, when Scala 2.11 was released, an important limitation was removed: 

Case classes with > 22 parameters are now allowed.

That said, there still exists a limit on the number of case class fields, please see https://stackoverflow.com/a/55498135/1586965

This may lead you to think there are no 22 limits in Scala, but that’s not the case. The limit lives on in functions and tuples.

The fix (PR 2305) introduced in Scala 2.11 removed the limitation for the above common scenarios: constructing case classes, field access (including copying), and pattern matching (baring edge cases).

It did this by omitting unapply and tupled for case classes above 22 fields.
In other words, the limit to Function22 and Tuple22 still exists.

Working around the Limit (post Scala 2.11)

There are two common tricks for getting around this limit.

  • The first is to use nested tuples.
    Although it’s true a tuple can’t contain more than 22 elements, each element itself could be a tuple

  • The other common trick is to use heterogeneous lists (HLists), where there’s no 22 limit.

If you want to make use of case classes, you may be better off using the shapeless HList implementation. We’ve created the Slickless library to make that easier. In particular the recent mappedWith method converts between shapeless HLists and case classes. It looks like this:

import slick.driver.H2Driver.api._
import shapeless._
import slickless._

class LargeTable(tag: Tag) extends Table[Large](tag, "large") {
  def a = column[Int]("a")
  def b = column[Int]("b")
  def c = column[Int]("c")
  /* etc */
  def u = column[Int]("u")
  def v = column[Int]("v")
  def w = column[Int]("w")

  def * = (a :: b :: c :: /* etc */ :: u :: v :: w :: HNil)
    .mappedWith(Generic[Large])
}

There’s a full example with 26 columns in the Slickless code base.

More Related Contents:

  1. Case objects vs Enumerations in Scala
  2. Cleaner way to update nested structures
  3. Case class equality in Apache Spark
  4. What is the difference between Scala’s case class and class?
  5. How to define schema for custom type in Spark SQL?
  6. How to override apply in a case class companion
  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. How to define “type disjunction” (union types)?
  20. How to define partitioning of DataFrame?
  21. In Scala, what is an “early initializer”?
  22. What is the motivation for Scala assignment evaluating to Unit rather than the value assigned?
  23. What’s the difference between == and .equals in Scala?
  24. Reading DataFrame from partitioned parquet file
  25. Scala: convert map to case class
  26. Build.scala, % and %% symbols meaning
  27. Differences between these three ways of defining a function in Scala
  28. How can I connect to a postgreSQL database into Apache Spark using scala?
  29. How to serve uploaded files in Play!2 using Scala?
  30. How to instantiate an instance of type represented by type parameter in Scala

Leave a Comment