A modern programming language that makes developers happier.

kotlinlang

Hi! How can I use generic type parameters in lambda types?
For example:
```val list = listOf&lt;&lt;T&gt;(x: T) -&gt; Unit&gt;()```

Where would you then actually define what `T` is?

Since you're creating an instance of this list there, you would have to define T right at this moment anyway, so what would be the point of using a generic type?

If you want to create a list of functions that accept any type of arguments, use `Any` or `Any?` instead of `T`

```val list: List&lt;(Int) -&gt; String&gt; = listOf&lt;(Int) -&gt; String&gt;({ x: Int -&gt; ""})```
Without generics this is the fully-qualified way to define a list here

If you had this inside a class that had a generic, this is an option.

```class MyClass&lt;T&gt; {
    val list: List&lt;(T) -&gt; String&gt; = listOf&lt;(T) -&gt; String&gt;({ x: T -&gt; ""})
}```


If you had a function with generics:

```fun &lt;T&gt; myFunction(): List&lt;(T) -&gt; String&gt; = listOf&lt;(T) -&gt; String&gt;({ x: T -&gt; ""})

val list: List&lt;(Int) -&gt; String&gt; = myFunction&lt;Int&gt;()```

Remove the details and verbosity when you figure it out, but I recommend starting by fully qualifying all the types. That will help give you more precise and helpful compiler errors.

That's exactly what I meant with "where would you define `T`".
If it is defined by an outer scope it could simply be used.
But from the broken example in the OP, he wants to do it without a generic type from outer scope

<@UBXMWAA69>
&gt; If you want to create a list of functions that accept any type of arguments, use `Any` or `Any?` instead of `T`
This actually also does not work:
```val list = listOf&lt;(Any) -&gt; Unit&gt;({ s: String -&gt; Unit }, { s: Exception -&gt; Unit })```


I spoke too fast actually. You're right. The variance is the opposite, you can't do anything with a list of a arbitrary functions. What you can do is pass a list of functions that _*all*_ accept `Any`

You would have to cast it inside the function

I guess you are looking for fun interfaces -&gt; <https://kotlinlang.org/docs/fun-interfaces.html>

Helpful, yes. But it doesn’t solve the problem of when you have to know the concrete type.

Ah...I misread the question...I bet you look for something like:
```val list = listOf&lt;Function1&lt;*, Unit&gt;&gt;(
    { x: Int -&gt; x+2 }
)```
However the caller of the list needs to know then which index holds which lambda.

Related: <https://youtrack.jetbrains.com/issue/KT-34470>