In Scala can I implement a def with a case class? - scala

Question

In Scala 2.12, I can implement a nullary method with a case object:
trait T[X] {
def f: X
}
trait XImpl {
def sayHi: String
}
object O extends T[XImpl] {
case object f extends XImpl {
val sayHi = "Hi"
}
}
> defined trait T
> defined trait XImpl
> defined object O
But if I add a method with arguments, and implement it with a case class, it does not work:
trait T[X] {
def f: X
def g(x: X): X
}
trait XImpl {
def sayHi: String
}
object O extends T[XImpl] {
case object f extends XImpl {
val sayHi = "Hi"
}
case class g(x: XImpl) extends XImpl {
def sayHi = x.sayHi.toUpperCase
}
}
> error: object creation impossible, since method g in trait T of type (x: XImpl)XImpl is not defined
Is there some magic to make it work, or do I have to implement a method that simply instantiates the case class ?

Answer 1

An object behaves like a (lazy) val, and that's why it can be used to implement a nullary def.
A case class is a combination of a class and an object (and so a lazy val), but neither of them can implement a def with parameters.
This also means that making your class implicit instead of case works, because then it defines an implicit def with that name as well. But I wouldn't recommend it to solve this problem.
do I have to implement a method that simply instantiates the case class
Yes. Note that to avoid accidental recursion it needs to be
def g(x: XImpl) = new g(x) // or g.apply(x), but not g(x)

Answer 2

The thing is that case class are not instances.
But to satisfy your trait T, you need to ensure that O implementing T[XImpl] has a property named g which confirms to type XImpl. And surely your case class g does not.
And if you are thinking about the companion object of g, then it conforms to the anonymous type g.type and will not confirm to XImpl.