How to combine variable argument definitions and function with receiver in Kotlin - kotlin

Question

In Kotlin I am able to define a function that accepts a variable number of arguments (see: testVariableArguments below) and I can define a function with a specified receiver (see: testFunctionWithReceiver below). I am wondering if there is a way to combine both of these concepts?
fun main(args: Array<String>) {
testVariableArguments { a: Int -> println(a) }
testVariableArguments { a: Int, b: Int -> println("$a, $b") }
testVariableArguments { a: Int, b: Int, c: Int -> println("$a, $b, $c") }
testVariableArguments { a: Int, b: Int, c: Int, d: Int -> println("$a, $b, $c, $d") }
testFunctionWithReceiver {
doSomething()
doAnotherThing()
}
}
fun <R, T : Function<R>> testVariableArguments(function: T) {
val method = function::class
.java
.declaredMethods
// May need to do something else here to get the
// correct method in case the return type is
// expected to be Object, but for my case it
// would never be Object
.first { m -> m.name == "invoke" && m.returnType != Object::class.java }
val args = method
.parameterTypes
// Mapping to Int here for demonstration, in real
// situations would use the parameter types to
// create the correct value
.withIndex()
.map { i -> i.index }
// Not really needed, but would be if I were
// using multiple types and not just Int
.map { i -> i as Any }
.toTypedArray()
method.invoke(function, *args)
}
fun <R> testFunctionWithReceiver(function: MyInterface.() -> R) {
val myObject = object : MyInterface {
override fun doSomething() {
println("doing something")
}
override fun doAnotherThing() {
println("doing another thing")
}
}
function(myObject)
}
interface MyInterface {
fun doSomething()
fun doAnotherThing()
}
EDIT:
I have found a way to combine these two features, but it is a bit messy at the call site, so if there is a better approach I would be interested.
What I did was add the following operator function to MyInterface
operator fun <R, T : Function<R>> T.unaryPlus() {
testVariableArgumentDefinition(this)
}
Then when I call testFunctionWithReceiver I do the following:
testFunctionWithReceiver {
+{ a: Int, b: Int ->
println("$a, $b")
doSomething()
doAnotherThing()
}
}

Answer 1

You can add parameter requirements to the closure called with receiver by adding:
MyInterface.(P) -> R
Replacing your creation of test parameters with a fixed one, this is what it might look like:
fun <R, P> testVariableArgumentsWithReceiver(param: P, function: MyInterface.(P) -> R) {
function.invoke(myObject, param)
}
fun main(args: Array<String>) {
testVariableArgumentsWithReceiver(17) { a: Int ->
println("$a")
doSomething()
doAnotherThing()
}
}
Of course, you're not as flexible here as you need to pass a single value of type P (which could be an array). You can extend it to MyInterface.(P,Q) but not arbitrary signatures per se.
What you truly want is a signature like this:
fun <R, T: Function<R>> someName(function: MyInterface.T)
or
fun <R, T: FunctionWithReceiver<MyInterface, R>> someName(function: T)
To my knowledge, neither can currently be expressed:
Only function-type literals seem to be allowed as part of extension types; MyInterface.T is not valid code.
There doesn't seem to be a first-class type for functions with receiver; we can't declare FunctionWithReceiver.
This may be worthwhile to bring up on discuss.kotlinlang.org