Solution: Function caller

class FunctionCaller {
    private var values: MutableMap<KType, Any?> =
        mutableMapOf()

    inline fun <reified T> setConstant(value: T) {
        setConstant(typeOf<T>(), value)
    }

    fun setConstant(type: KType, value: Any?) {
        values[type] = value
    }

    fun <T> call(function: KFunction<T>): T {
        val args = function.parameters
            .filter { param ->
                values.containsKey(param.type)
            }
            .associateWith { param ->
                val type = param.type
                val value = values[type]
                require(param.isOptional || value != null) {
                    "No value for $type"
                }
                value
            }
        return function.callBy(args)
    }
}

Example solution in playground

import org.junit.After
import org.junit.Test
import kotlin.reflect.KFunction
import kotlin.reflect.KType
import kotlin.reflect.typeOf
import kotlin.test.assertEquals

class FunctionCaller {
    private var values: MutableMap<KType, Any?> =
        mutableMapOf()

    inline fun <reified T> setConstant(value: T) {
        setConstant(typeOf<T>(), value)
    }

    fun setConstant(type: KType, value: Any?) {
        values[type] = value
    }

    fun <T> call(function: KFunction<T>): T {
        val args = function.parameters
            .filter { param ->
                values.containsKey(param.type)
            }
            .associateWith { param ->
                val type = param.type
                val value = values[type]
                require(param.isOptional || value != null) {
                    "No value for $type"
                }
                value
            }
        return function.callBy(args)
    }
}

fun printStrIntNum(str: String, int: Int, num: Number) {
    println("str: $str, int: $int, num: $num")
}

fun printWithOptionals(l: Long = 999, s: String) {
    println("l: $l, s: $s")
}

fun main() {
    val caller = FunctionCaller()
    caller.setConstant("ABC")
    caller.setConstant(123)
    caller.setConstant(typeOf<Number>(), 3.14)
    caller.call(::printStrIntNum)
    // str: ABC, int: 123, num: 3.14
    caller.call(::printWithOptionals)
    // l: 999, s: ABC
}

class FunctionCallerTest {
    var value: Any? = null
    fun callStr(str: String) {
        value = "callStr $str"
    }

    fun callInt(int: Int) {
        value = "callInt $int"
    }

    fun callStringInt(str: String, int: Int) {
        value = "callStringInt $str $int"
    }

    data class User(val id: Int, val name: String?, var surname: String?)

    fun callUser(user: User) {
        value = user
    }

    fun callWithDefault(c: Char, i: Int = 999, s: String = "XXX", l: Long) {
        value = "callWithDefault $c $i $s $l"
    }

    @After
    fun cleanUp() {
        value = null
    }

    @Test
    fun testWithString() {
        val caller = FunctionCaller()
        caller.setConstant("ABC")
        caller.call(::callStr)
        assertEquals("callStr ABC", value)
    }

    @Test
    fun testWithInt() {
        val caller = FunctionCaller()
        caller.setConstant(123)
        caller.call(::callInt)
        assertEquals("callInt 123", value)
    }

    @Test
    fun testWithStringInt() {
        val caller = FunctionCaller()
        caller.setConstant("DEF")
        caller.setConstant(456)
        caller.call(::callStringInt)
        assertEquals("callStringInt DEF 456", value)
    }

    @Test
    fun testWithUser() {
        val caller = FunctionCaller()
        val user = User(123, "DEF", "GHI")
        caller.setConstant(user)
        caller.call(::callUser)
        assertEquals(user, value)
    }

    @Test
    fun testIgnoredOptional() {
        val caller = FunctionCaller()
        caller.setConstant('Z')
        caller.setConstant(123L)
        caller.call(::callWithDefault)
        assertEquals("callWithDefault Z 999 XXX 123", value)
    }
}