Hey, I’m looking for a way to wrap a method into a...

# getting-started

[krzysztof]

Hey, I’m looking for a way to wrap a method into a higher-order function that runs some checks, before running that method. 🧵

[krzysztof]

I have a few methods that I pass down to other method as callbacks:

giantMethod(
 onCallbackOne: inst::method1,
 onCallbackTwo: inst::method2
)

both method1 and method2 have different arity and/or parameter types

[krzysztof]

I’d like to run some checks, before method* is called, but still be able to pass it down to giantMethod like so:

giantMethod(
 onCallbackOne: check(inst::method1),
 onCallbackTwo: check(inst::method2)
)

[krzysztof]

Is there a way to achieve this in some nice way?

[Jimmy Zhou]

how do you plan to wrap them? by annotation or by abstract class?

[Youssef Shoaib [MOD]]

I had just implemented something similar. One sec while I adapt it to your needs

[Jimmy Zhou]

you can define an abstract class and do something like this

open suspend fun <T : Any?> giantMethod(
        function: suspend () -> T?
    ): T? {
         // add some other logic
         runCatching { function() }
         ....
         // some other logic
    }

or you can use @AspectJ then use joinPoints and annotate your method/class

[ephemient]

in pure Kotlin, you need overloads for different arities

[krzysztof]

Looking for something that resembles JS’ spread operator, such as:

giantMethod(
 onCallbackOne: (...args) => check(method1, args))
)

So that once logic in check method is completed, method1 will be called with args arguments passed

[ephemient]

how would you write that type in Kotlin?

[Youssef Shoaib [MOD]]

(Playground):

import kotlin.reflect.*
typealias Wrapper<R> = (() -> R) -> R

fun <R> checker(): Wrapper<R> = { block ->
    // Run some checks
    require(Unit is Unit)
    println("Checking")
    block()
}

fun giantMethod(getter: () -> Int, setter: (Int) -> Unit) {
    setter(getter() + 1)
}
var myInt = 41
fun main() {
    val setter: (Int) -> Unit = { myInt = it }
    giantMethod(::myInt.wrappedWith(checker()), setter.wrappedWith(checker()))
    println(myInt)
}

// You'll need one wrappedWith function per arity, but that shouldn't be that big of a deal since
// you usually won't have a function bigger than 10-15 parameters.
fun <R> (() -> R).wrappedWith(wrapper: Wrapper<R>): () -> R = {
    wrapper {
        invoke()
    }
}
fun <T1, R> ((T1) -> R).wrappedWith(wrapper: Wrapper<R>): (T1) -> R = { t1 ->
    wrapper {
        invoke(t1)
    }
}
fun <T1, T2, R> ((T1, T2) -> R).wrappedWith(wrapper: Wrapper<R>): (T1, T2) -> R = { t1, t2 ->
    wrapper {
        invoke(t1, t2)
    }
}
fun <T1, T2, T3, R> ((T1, T2, T3) -> R).wrappedWith(wrapper: Wrapper<R>): (T1, T2, T3) -> R = { t1, t2, t3 ->
    wrapper {
        invoke(t1, t2, t3)
    }
}
fun <T1, T2, T3, T4, R> ((T1, T2, T3, T4) -> R).wrappedWith(wrapper: Wrapper<R>): (T1, T2, T3, T4) -> R = { t1, t2, t3, t4 ->
    wrapper {
        invoke(t1, t2, t3, t4)
    }
}

[Youssef Shoaib [MOD]]

It requires a wrappedWith method for every arity, but it allows you to have unlimited checker varieties, because the checker doesn't need to know anything about the arguments of the function

[ephemient]

yeah, as I mentioned earlier

[ephemient]

it'll fail after 22 parameters because the function types aren't different anymore, but it should be enough for almost all practical purposes

[krzysztof]

that’s super useful, thank you 🙏 I guess I expected that vararg arg: Any? would cover cases for arbitrary arity, but I expected wrongly

[ephemient]

no, because a vararg function has a different signature than a function taking a fixed number of arguments

[Youssef Shoaib [MOD]]

ephemient is right in that it fails after 22, but not because of the compiler type system. In fact, the type system can still differentiate between a 23 vs a 24 function. It fails because it gets compiled down to the same class (FunctionN I think). This can be easily solved with @JvmName though. Here's an example of it working for 23 vs 24 (Playground):

import kotlin.reflect.*
typealias Wrapper<R> = (() -> R) -> R

fun <R> checker(): Wrapper<R> = { block ->
    // Run some checks
    require(Unit is Unit)
    println("Checking")
    block()
}

fun giantMethod(getter: (Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int) -> Int,
                setter: (Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int) -> Unit) {
    setter(getter(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) + 1,
          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)
}
var myInt = 41
fun main() {
    // 23 args
    val getter: (Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int) -> Int = 
    { _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ -> 
        myInt 
    }
    // 24 args
    val setter: (Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int, Int) -> Unit = 
    { it, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ -> 
        myInt = it 
    }
    giantMethod(getter.wrappedWith(checker()), setter.wrappedWith(checker()))
    println(myInt)
}

// 23
@JvmName("wrappedWith23")
fun <T, R> ((T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) -> R).wrappedWith(wrapper: Wrapper<R>): (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) -> R = 
    { t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23 ->
    wrapper {
        invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23)
    }
}
// 24
@JvmName("wrappedWith24")
fun <T, R> ((T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) -> R).wrappedWith(wrapper: Wrapper<R>): (T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T) -> R = 
    { t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24 ->
    wrapper {
        invoke(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20, t21, t22, t23, t24)
    }
}

[ephemient]

well, I didn't go into that detail, but that's what I meant 😛 it's documented in https://github.com/Kotlin/KEEP/blob/master/proposals/functional-types-with-big-arity-on-jvm.md

[ephemient]

also, suspend functions "use up" one parameter, so if you create

suspend fun <T1...T21, R> wrapper(block: suspend (T1...T21) -> R): suspend (T1..T21) -> R

etc. overloads, you run into the issue a little earlier

[krzysztof]

Thank you both 🙏