Is this something outference would solve? ```fun L...

# language-evolution

[Youssef Shoaib [MOD]]

Is this something outference would solve?

fun List<*>.foo() {}
emptyList().foo()

I get an error on emptyList(). I understand why, of course, but it feels like overprecise initialisation to me!
This example would be nice to support as well, although I can imagine it'd be harder:

fun List<String>.foo() {}
emptyList().foo()

(thus `emptyList`'s type arg is String)

[dmitriy.novozhilov]

What about this?

fun List<*>.foo() {}
fun List<String>.foo() {}

emptyList().foo()

[Youssef Shoaib [MOD]]

An error here would be perfectly apt in my opinion.
Interestingly, builder inference chooses the String overload:

fun List<*>.foo() { println(1) }
fun List<String>.foo() { println(2) }

buildList { foo() } // prints 2

but it does report ambiguity in this case:

fun List<Int>.foo() { println(1) }
fun List<String>.foo() { println(2) }

buildList { foo() }

Roughly, I want these "overprecise initialisation" situations to behave like builder inference. It sounds like maybe outference could do this

[Youssef Shoaib [MOD]]

Another interesting example:

fun <K> Map<K, *>.foo(key: K) {}
emptyMap().foo("foo")