Overloading constructors isn’t special for case classes: case class Foo(bar: Int, baz: Int) { def this(bar: Int) = this(bar, 0) } new Foo(1, 2) new Foo(1) However, you may like to also overload the apply method in the companion object, which is called when you omit new. object Foo { def apply(bar: Int) = new … Read more
My personal favorite method is to make use of the provided implicit ordering for Tuples, as it is clear, concise, and correct: case class A(tag: String, load: Int) extends Ordered[A] { // Required as of Scala 2.11 for reasons unknown – the companion to Ordered // should already be in implicit scope import scala.math.Ordered.orderingToOrdered def … Read more
One word: equality case classes come with a supplied implementation of equals and hashCode. The equivalence relation, known as equals works like this (i.e. must have the following properties): For all x; x equals x is true (reflexive) For x, y, z; if x equals y and y equals z then x equals z (transitive) … Read more
My preferred way of avoiding case class inheritance without code duplication is somewhat obvious: create a common (abstract) base class: abstract class Person { def name: String def age: Int // address and other properties // methods (ideally only accessors since it is a case class) } case class Employer(val name: String, val age: Int, … Read more
This should work: def getCCParams(cc: AnyRef) = cc.getClass.getDeclaredFields.foldLeft(Map.empty[String, Any]) { (a, f) => f.setAccessible(true) a + (f.getName -> f.get(cc)) }
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
The reason for the conflict is that the case class provides the exact same apply() method (same signature). First of all I would like to suggest you use require: case class A(s: String) { require(! s.toCharArray.exists( _.isLower ), “Bad string: “+ s) } This will throw an Exception if the user tries to create an … Read more
Spark 2.0.0+: UserDefinedType has been made private in Spark 2.0.0 and as for now it has no Dataset friendly replacement. See: SPARK-14155 (Hide UserDefinedType in Spark 2.0) Most of the time statically typed Dataset can serve as replacement There is a pending Jira SPARK-7768 to make UDT API public again with target version 2.4. See … Read more
Case classes can be seen as plain and immutable data-holding objects that should exclusively depend on their constructor arguments. This functional concept allows us to use a compact initialization syntax (Node(1, Leaf(2), None))) decompose them using pattern matching have equality comparisons implicitly defined In combination with inheritance, case classes are used to mimic algebraic datatypes. … Read more
This is a known issue with Spark REPL. You can find more details in SPARK-2620. It affects multiple operations in Spark REPL including most of transformations on the PairwiseRDDs. For example: case class Foo(x: Int) val foos = Seq(Foo(1), Foo(1), Foo(2), Foo(2)) foos.distinct.size // Int = 2 val foosRdd = sc.parallelize(foos, 4) foosRdd.distinct.count // Long … Read more