Case classes in Scala with behavior - class

Question

I have a Scala case class that has certain val's as parameters. I have a couple of methods that makes use of this case class. Assuming that my case class is defined as follows:
case class CaseA(a: Int, b: List[CaseB])
case class CaseB(a: Int, b: text, c: Boolean)
Both the CaseA and CaseB represent the domain model of my case classes. But as I use them in my application, I want to add some behavior to CaseA based on CaseB's Boolean field. For example., let us suppose that in CaseA, the val b has 4 CaseB objects. I want to add a behavior that would run through b and tell me if any one of the element in CaseB has the val c set to true.
What I did come up is with the following implementation of CaseA:
case class CaseA(a: Int, b: List[CaseB], c: Boolean)
But the problem with this approach is that when I load my CaseA object from the database, I do not need to have the val c as the val c is computed and not part of CaseA object. I went a step further and modified my CaseA to look like as below:
case class CaseA(a: Int, b: List[CaseB], c: Option[Boolean])
I can see that it is already getting ugly. How can I add behavior to my case classes so that the val c need not be part of the CaseA object and it is rather computed everytime at runtime?

Answer 1

I would use a lazy value in case you don't need the c for all elements
case class CaseB(a:Int,b:String,c:Boolean)
case class CaseA(a:Int,b:List[CaseB]){
lazy val c = b exists (_.c)
}
val ca = CaseA(42, List(
CaseB(1,"hello",false),
CaseB(2,",",false),
CaseB(3,"world",true))
)
println(ca.c)
To answer some of your comment questions, if you want to use a mixin-trait, you can do something like the following:
case class CaseB(a:Int,b:String,c:Boolean)
case class CaseA(a:Int,b:List[CaseB])
trait CanCheck extends CaseA{
lazy val c = b exists (_.c)
}
val ca = new CaseA(42, List(
CaseB(1,"hello",false),
CaseB(2,",",false),
CaseB(3,"world",true))
) with CanCheck
println(ca.c)
Notice that you need to use the new keyword to make this work

Answer 2

In a two ways:
1) define c as a val, or even better, as a def:
case class CaseA(a: Int, b: List[CaseB]){
val c = b.exists(_.c)
}
2) use implicit wrappers:
case class CaseA(a: Int, b: List[CaseB])
implicit class CaseAC(underlying: CaseA) {
val c = underlying.b.exists(_.c)
}
val x = CaseA(3, Nil)
// x: CaseA = CaseA(3,List())
x.c
// Boolean = false
If you don't need to store c, you might use implicit value classes, which are even thinner wrapper

Answer 3

I don't understand what you are doing with a database. Ignoring that bit, I'd do the following:
case class CaseA(a: Int, b: List[CaseB]){
val c = b.exists(_.c)
}