is there a typesafe way to do partial application in kotlin? I’ve got a bunch of objects with a run ...

# announcements

[Bernhard]

is there a typesafe way to do partial application in kotlin? I’ve got a bunch of objects with a run method that receives a variable amount of different parameters and I need to make it fit an interface which takes only one common parameter. Not super keen on creating a factory class per object.

[nfrankel]

vararg comes to mind
https://kotlinlang.org/docs/reference/functions.html#variable-number-of-arguments-varargs

[Bernhard]

yep, but I’ve got different types as well

[Bernhard]

basically: run(common: Common, value1: String) and run(common: Common, value1: Int, value2: URI)

[Bernhard]

I want to make them fit an interface that requires run(common: Common)

[Bernhard]

ideally I could do something like:
val x: CommonRun = obj1.run.apply("hi")
val y: CommonRun = obj2.run.apply(3, URI("<https://google.com>"))

[Bernhard]

I’d need to move the common stuff at the end ofc

[Bernhard]

I could ofc do:

val x = CommonRun { obj1.run(it, "hi") }

but that’s a bit clunky

[Nir]

Why's that clunky? Seems reasonably concise and nicely explicit to me

[nfrankel]

i’m afraid that you’d need a dynamically-typed language
in kotlin, you’d pass an vararg of Any
and you need to cast in subclasses
🤷‍♂️

[nfrankel]

passing a lambda is a nice trick 👍

[kralli]

I’m not exactly sure of what you are trying to achieve, but you could experiment with extension functions. This would allow your interface to only have a single method and to still elegantly support all cases in a type safe manner.

fun Common.run(value: Int): CommonRun = TODO()

[Bernhard]

I need a way to bind the additional parameters in code though, not sure how an extension function would help

[kralli]

Well, you would pass them and capture them somehow in your extension function. I have too little information to give you an exact example.

[Nir]

You don't need a dynamically typed language, but you do probably need variadics to do this properly

[Nir]

youcould do this in C++, but it's pretty painful

[Nir]

In Kotlin, you'd have to write overloads for apply in both the ari-ness of the passed function, and in the position of common

[Nir]

fun<T, R> apply(fun: (T, Common) -> R, t: T) = { fun(t, it) }
fun<T, R> apply(fun: (Common, T) -> R, t: T) = { fun(it, t) }

fun<T, U, R> apply(fun: (Common, T, U) -> R, t: T, u: U) = { fun(it, t, u) }
fun<T, U, R> apply(fun: (T, Common, U) -> R, t: T, u: U) = { fun(t, it, u) }
fun<T, U, R> apply(fun: (T, U, Common) -> R, t: T, u: U) = { fun(t, u, it) }
...

[Nir]

i think something like that should work but it's a bit horrible

[Nir]

but this probably has edge cases and such, I think it's a lot better to just do the same thing at the call site, as you had before (the code you called "clunky")