Scala case class: avoid recomputation of the property - scala

Question

I am asking this because I have encountered this use case many times.
Let's say we have a case class like this:
case class C(xs: Iterable[Int]) {
val max = xs.max
def ++(that: C) = C(xs ++ that.xs)
}
This works fine, but the ++ operation is inefficient, since the collection is needlessly traversed once more to compute the maximum of the result; since we already know the maximums of both collections, we could reuse that - by using something like this:
def ++(that: C) =
C(xs ++ that.xs, max = math.max(max, that.max))
This is just a simple example to demonstrate the purpose - the computation avoided could be a lot more complex, or maybe even a TCP data fetch.
How to avoid this recomputation (see the second code snippet), keeping the code elegant?

Answer 1

Something like this would work
class C private (val xs: Iterable[Int], val max: Int) {
def ++(that: C) = new C(xs ++ that.xs, math.max(this.max, that.max)
}
object C {
def apply(xs: Iterable[Int]) = new C(xs, xs.max)
}
Note that C is no longer a case class to avoid max and xs becoming inconsistent. If C was a case class, you could call e.g. c.copy(max = -1) and get an inconsistent instance.

Answer 2

case class C(xs: Iterable[Int]) {
private var maxOp = Option.empty[Int]
lazy val max = maxOp getOrElse {
maxOp = Some(xs.max)
maxOp.get
}
def ++(that: C) = {
val res = C(xs ++ that.xs)
res.maxOp = Some(math.max(this.max, that.max))
res
}
}

Answer 3

Since max is already a val (in contrast to a method) you could do it this way:
case class C private (xs: Iterable[Int], max: Int) {
def ++(that: C) = C(xs ++ that.xs, math.max(max, that.max))
def copy(_xs: Iterable[Int] = this.xs) = {
if (_xs == this.xs) {
C(xs, max)
} else {
C(_xs)
}
}
}
object C {
def apply(xs: Iterable[Int]): C = C(xs, xs.max)
}
If you are going to pattern match on this case class, then it depends on your use cases, if you can (or must) pattern match on max as well.
Update 1 As pointed out by Rüdiger I have added private to the constructor so that xs and max are consistent.
Update 2 As pointed out by som-snytt, the copy method must be handled as well to to prevent inconsistency.

Answer 4

sealed trait C {
val xs: Iterable[Int]
val max: Int
def ++(that: C) = ComposedC(this, that)
}
case class ValidatedC(xs: Iterable[Int]) extends C {
val max = xs.max
}
case class ComposedC(a: C, b: C) extends C {
val max = math.max(a.max, b.max)
val xs = a.xs ++ b.xs
}
object C {
def apply(xs: Iterable[Int]) = ValidatedC(xs)
}
A simpler solution (which doesn't enforce correctness) -
Introduce a way to provide pre-computed max and an auxiliary constructor that gets 2 Cs.
case class C(xs: Iterable[Int])(val max: Int = xs.max) {
def this(a: C, b: C) = {
this(a.xs ++ b.xs)(math.max(a.max, b.max))
}
def ++(that: C) = new C(this, that)
}