Scala generics: why two types with the same upper bound are not compatible? - scala

Question

I am confused with how bounds work in Scala generics. Consider the following:
sealed trait MessageBody
case class Body1() extends MessageBody
case class Body2() extends MessageBody
sealed trait MessageKey[T <: MessageBody]
case object Key1 extends MessageKey[Body1]
case object Key2 extends MessageKey[Body2]
type MessageHandler[B <: MessageBody] = PartialFunction[MessageKey[B], B => Unit]
abstract class Handler {
def messageHandler[B <: MessageBody]: MessageHandler[B]
}
class ProcessingHandler[ReturnType <: MessageBody](val onSuccess: MessageKey[ReturnType]) extends Handler {
override def messageHandler[B <: MessageBody]: MessageHandler[B] = {
case `onSuccess` => success
}
def success(msg: ReturnType): Unit = println(msg)
}
This gives me an error:
error: type mismatch;
found : ReturnType => Unit
required: B => Unit
case `onSuccess` => success
^
In my naive understanding, both ReturnType and B are subtypes of MessageBody and thus must be compatible. So why are they not compatible, and how should I write my code to make them compatible?
EDIT: The following piece of code works just fine, and if I mix the relation between the MessageKey and MessageBody instances anywhere, I get a nice compile time error.
class ProcessingHandler2 extends Handler {
override def messageHandler[B <: MessageBody]: MessageHandler[B] = {
case Key1 => h1
// case Key1 => h2 // gives compile-time error
case Key2 => h2
}
def h1(x: Body1): Unit = println(x)
def h2(x: Body2): Unit = println(x)
}
val handler: Handler = new ProcessingHandler2
handler.messageHandler(Key1)(Body1())
// handler.messageHandler(Key1)(Body2()) // gives compile-time error
EDIT: Obviously, there is no way to compile check this: handler.messageHandler(Key3) and this will result in a MatchError at run-time.

Answer 1

Let's say you have an object of type ProcessingHandler[Body1] and then call messageHandler[Body2] on it. According to the signature, it should return a Body2 => Unit, but you try to return a Body1 => Unit. If you were trying to return a MessageBody => Unit, that would be fine as MessageBody is a superclass of Body2, but Body1 is not. They're both children of the same superclass, but that doesn't make them compatible, that is you can't pass a Body2 as an argument to a function that takes a Body1 or vice versa.
Depending on what exactly your requirements are, there are multiple things you could do:
You could make Handler generic instead of messageHandler and then extend Handler[ReturnType] (or you could give Handler a member type and use it in messageHandler).
Or you could make success take a MessageBody as its argument instead of a ReturnType.