A modern programming language that makes developers happier.

kotlinlang

Hi, how to obtain all functions that have a functional parameter using Kotlin Reflect?
I tried something like
```
Class.forName("myClass").declaredMethods.map { it.kotlinFunction!! }.filter { fn -&gt; fn.parameters.any { it is KFunction&lt;*&gt; } }
```
but it didn't work

Do you have an example what you want to look for?

I  have a lot of function overloads, such as
```
fun foo&lt;A&gt;(fn: (A) -&gt; Unit) {}
fun foo&lt;A. B&gt;(fn: (A, B) -&gt; Unit) {}
fun foo &lt;A, B, C&gt;(fn: (A, B, C) -&gt; Unit) {}
...
```

I want to find all the functions that contain this kind of `fn`

So I wanted to filter for ```Foo::class.filter { function -&gt; function.parameters.any { /* it is of function type */  } ```

The original problem is I want to write a test for all these functions, but don't want to write 22 tests

As their behavior is pretty much the same

this seems to work :
```
fun main(args: Array&lt;String&gt;) {
    val funcs = Foo::class.declaredFunctions.filter { func -&gt;
        func.parameters.any { param -&gt;
            param.type.isSubtypeOf(Function::class.starProjectedType)
        }
    }

    println(funcs)
}

class Foo {
    fun &lt;A&gt; foo(fn: (A) -&gt; Unit) {}
    fun &lt;A, B&gt; foo2(fn: (A, B) -&gt; Unit) {}
    fun &lt;A, B, C&gt; foo3(fn: (A, B, C) -&gt; Unit) {}

    fun notThisOne() { }
}
```

since this is for unit tests it should be good enough, but I'm not sure enough about all edge cases with this (ex: I don't think it would catch java functional interfaces and stuff like that)

and the `Function` is kotlin`s `Function` in the kotlin package, not java.lang.Function btw