This is an expected behavior because of how case class works. case class automatically extends two traits, namely Product and Serializable. Product trait is extended as case class is an algebraic data type with product type. Serializable trait is extended so that case class can be treated as a pure data – i.e capable of … Read more
There are several frameworks which can exactly do that. circe Used a lot nowdays. Many great features. Will pull cats in. https://circe.github.io/circe/ https://github.com/circe/circe JSON4s JSON4s is quite mature and supports jackson or a native JSON-Parser. Used it in many projects to replace jerkson. https://github.com/json4s/json4s play-json Can be used without the full play stack. Great support … Read more
It is really easy to accidentally use a no-arg case class incorrectly as a pattern. scala> case class Foo warning: there were deprecation warnings; re-run with -deprecation for details defined class Foo scala> (new Foo: Any) match { case Foo => true; case _ => false } res10: Boolean = false Instead of: scala> (new … Read more
Here’s the technique to have a private constructor and a public apply method. trait Meter { def m: Int } object Meter { def apply(m: Int): Meter = { MeterImpl(m) } private case class MeterImpl(m: Int) extends Meter { println(m) } } object Application extends App { val m1 = new Meter(10) // Forbidden val … Read more
You can also write (Person.apply _).tupled to avoid repeating the types.
This is very subjective of course, but in my opinion it is good practice to have exception classes as case classes. The main rationale being that when you catch an exception, you are doing pattern matching, and case classes are much nicer to use in pattern matching. Here’s an example that takes advantage of the … Read more
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 … Read more
Check out a small extensions library named sext. It exports these two functions exactly for purposes like that. Here’s how it can be used for your example: object Demo extends App { import sext._ case class ClassDecl( kind : Kind, list : List[ VarDecl ] ) sealed trait Kind case object Complex extends Kind case … Read more
As my professor used to say, only the code tells the truth! So just take a look at the code that is generated for: case class A(i: Int, s: String) We can instruct the Scala compiler to show us the generated code after the different phases, here after the typechecker: % scalac -Xprint:typer test.scala [[syntax … Read more
It is not redundant in the sense that using it does change things. As one would expect, you cannot extend a final case class, but you can extend a non-final one. Why does wartremover suggest that case classes should be final? Well, because extending them isn’t really a very good idea. Consider this: scala> case … Read more