A modern programming language that makes developers happier.

kotlinlang

Is there a way to resolve the "Overload resolution ambiguity" without having dedicated function names?
```fun <T : Any> foo(block: () -> T?) {}
fun <T : Any> foo(block: () -> List<T>?) {}
fun <K : Any, V : Any> foo(block: () -> Map<K, V>?) {}
fun <T : Any> foo(block: () -> Set<T>?) {}
foo { "foo" }
foo { listOf("foo") }
foo { mapOf("foo" to "bar") }
foo { setOf("foo") }```
(And without casting the arguments, I mean that the right method is used automatically)

There's a `@OverloadResolutionByLambdaReturnType` annotation that might help. What do you expect `foo { null }` to resolve to?

<https://kotlinlang.org/api/core/kotlin-stdlib/kotlin/-overload-resolution-by-lambda-return-type/>

It might not help in this case. Since your first generic function is always valid, I'm not sure you can avoid either a resolution ambiguity or a declaration clash.

Ah, thanks, that helps indeed.
The `null` case is fine to cast.
This works:
```@OptIn(ExperimentalTypeInference::class)
@OverloadResolutionByLambdaReturnType
fun &lt;T : Any&gt; foo(block: () -&gt; T?) {}
@JvmName("bar")
fun &lt;T : Any&gt; foo(block: () -&gt; List&lt;T&gt;?) {}
@JvmName("baz")
fun &lt;K : Any, V : Any&gt; foo(block: () -&gt; Map&lt;K, V&gt;?) {}
@JvmName("bam")
fun &lt;T : Any&gt; foo(block: () -&gt; Set&lt;T&gt;?) {}
foo { null as String? }
foo { "foo" }
foo { listOf("foo") }
foo { mapOf("foo" to "bar") }
foo { setOf("foo") }```

Grml not in all cases, Kotlin Compiler too old (don't ask) `NEW_INFERENCE_IS_LAMBDA_FOR_OVERLOAD_RESOLUTION_INLINE called with null value` :disappointed: