How to map string to function and call it later - kotlin

Question

I'm new to Kotlin and what I'm trying to achieve is very simple in dynamically typed languages like Python and JavaScript, but no so easy in Kotlin. I have a set of message handler functions accepting message objects. Each message class implements Message interface. I want to map each message handler function to a String key:
interface Message
data class TestMessage1(val body: String): Message
data class TestMessage2(val body: String): Message
fun testMessage1Handler(msg: TestMessage1) { println(msg.body) }
fun testMessage2Handler(msg: TestMessage2) { println(msg.body) }
val functions = mapOf<String, (Message)->Unit> (
"testMessage1" to ::testMessage1Handler,
"testMessage2" to ::testMessage2Handler
)
This code gives me two errros:
error: type inference failed.
Expected type mismatch: inferred type is
Pair<String, KFunction1<#ParameterName Line_1.TestMessage1, Unit>>
but
Pair<String, (Line_1.Message) -> Unit> was expected
error: type inference failed.
Expected type mismatch: inferred type is
Pair<String, KFunction1<#ParameterName Line_1.TestMessage2, Unit>>
but
Pair<String, (Line_1.Message) -> Unit> was expected
Why can't I use interface Message as function type parameter? Since both TestMessage1 and TestMessage2 implement this interface it seems correct to me. How would you implement something like this?
There is a related question How to save a function reference as the value in a Map type, and invoke it with a parameter later on in Kotlin? but I don't want to change message handler parameter msg type to Any

Answer 1

Let's look at in another way.
What if instead of trying and failing to specify the type, we give Kotlin chance to infer it, by specifying incorrect type:
val functions: String = mapOf(
"testMessage1" to ::testMessage1Handler,
"testMessage2" to ::testMessage2Handler
)
This produces:
inferred type is Map<String, KFunction1<*, Unit>> but String was expected.
Now if you put that signature, it will actually compile:
val functions = mapOf<String, KFunction1<*, Unit>>(
"testMessage1" to ::testMessage1Handler,
"testMessage2" to ::testMessage2Handler
)
This is similar to:
val functions: Map<String, KFunction1<*, Unit>> = mapOf(
"testMessage1" to ::testMessage1Handler,
"testMessage2" to ::testMessage2Handler
)
When trying to invoke this, though, you get a hint why this is not correct:
functions["testMessage1"]?.invoke(TestMessage1("a"))
Gets you
Type mismatch.
Required: Nothing
Found: TestMessage1
Notice that Kotlin infers that type of your input is Nothing
To understand why, let's look at only one function:
fun testMessage1Handler(msg: TestMessage1)
And ask ourselves: what other type besides TestMessage1 this function may receive? No other type. It cannot receive TestMessage2. It cannot receive Message, since Message is not necessarily TestMessage1.
For second function, we'll get the same answer. So, the common type of both is Nothing. Which makes this abstraction not very useful to begin with.

Answer 2

The following code compiles but renders the question kind of moot.
The type parameters match now. Maybe generics could be applied as well, but I don’t know how.
interface Message {
val body: String
}
data class TestMessage1(override val body: String): Message
data class TestMessage2(override val body: String): Message
fun messageHandler(msg: Message) { println(msg.body) }
val functions = mapOf<String, (Message)->Unit> (
"testMessage1" to ::messageHandler,
"testMessage2" to ::messageHandler
)