Cast functions in scala - scala

Question

I have the base class Message and two derived classes One and Two. Method regHandler accepts function Message => Message as argument. When i created method handler and passed it to regHandler, it throws cast error.
class Message
class One extends Message
class Two extends Message
type Handler = Message => Message
def regHandler(handler: Handler) {}
def handler(one: One) : Two = {
new Two
}
regHandler(handler) // <- error here
I tried change my code like this:
var f : Handler
def regHandler[T >: Message, R >: Message](handler: T => R) = {
f = handler // <- but cast error here occurred
}
How do i need change my code to make it work ?

Answer 1

There is a very good reason it doesn't work: your Handler definition says it accepts any Message, but handler only accepts One. Kolberg proposes one solution, but the simpler one would be just to fix handler:
def handler(m: Message) = m match {
case one: One => new Two
case _ => // whatever you want to do here
}
You can throw an exception, which would be equivalent to other answers, except you can have a better error message; you can remove the line, which will throw MatchError; you can return Option[Message]; etc.
Now you can assign it, store it in a map, etc. easily:
object Main extends App {
class Message
class One extends Message
class Two extends Message
type Handler = Message => Message
def regHandler(handler: Handler) {}
def handler(m: Message) = m match {
case one: One => new Two
case _ => throw new Exception(s"handler expected One, got $m")
}
regHandler(handler)
val f: Handler = handler // no _ required
val map: Map[String, Handler] = Map("1" -> handler)
}
Or if you really don't want to change method signatures, make Handlers out of them explicitly (it could be an implicit conversion as well, but since it can introduce errors, I don't recommend it):
object Handler {
def apply[A <: Message, B <: Message](f: A => B): Handler = f.asInstanceOf[Handler]
// alternately if you want to handle ClassCastException for wrong argument type
// def apply[A <: Message, B <: Message](f: A => B): Handler =
// x => try { f(x) } catch { case e: ClassCastException => ... }
}
regHandler(Handler(handler))

Answer 2

The type bounds in
def regHandler[T >: Message, R >: Message](handler: T => R) = {
are wrong, because with >: you are telling the compiler that T,R should be super types of Message. I think you want sub types of Message:
def regHandler[T <: Message, T <: Message](handler: T => R) {}
def handler(one: One) : Two = {
new Two
}
regHandler(handler)
works for me.
EDIT:
OK, my answer was incomplete. Here is a complete and working example:
class Message
class One extends Message
class Two extends Message
type Handler[A <: Message, B <: Message] = A => B
def regHandler[A <: Message, B <: Message](a: A)(handler: Handler[A, B]): Unit = {
println(s"${handler(a)}")
}
def handler(one: One) : Two = {
new Two
}
regHandler(new One)(handler)
EDIT 2:
For usage in a map function or to assign to a var/val in this specific scenario add _:
val f: Handler[_, _] = handler _
val map = Map(new One -> handler _)
val test = map.map {case (one, h) => h(one)}

Answer 3

You can use variance annotation with wildcard types. Check this:
object Main {
class Message
class One extends Message
class Two extends Message
class Three extends Message
class Four extends Message
type HandlerType[+A <: Message, +B <: Message] = A => B
var f: HandlerType[_, _] = _
def regHandler(handler: HandlerType[_, _]) = {
f = handler // <- but cast error here occurred
}
def main(args: Array[String]) {
def handler12(x: One): Two = new Two
def handler23(x: Two): Three = new Three
def handler34(x: Three): Four = new Four
val h12 = handler12(_)
val h23 = handler23(_)
val h34 = handler34(_)
val handlersMap: Map[String, HandlerType[_, _]] = Map(
"12" -> h12,
"23" -> h23,
"34" -> h34)
handlersMap foreach {
case (k, h) =>
println(k)
println(h)
val hd: HandlerType[Message, Message] = h
val m: Message = new One
println(hd(m))
}
regHandler(h12)
}
}
Although you can store the handlers into a map, it creates additional types which introduce more complexity. I think there should be a better way to handle this problem.