Kotlin: Inline lambda i przeciążenie rozdzielczości niejednoznaczności

Question

Mam prosty wzór fabryczny, w którym implementacja jest określana poprzez rozdzielczość przeciążenia. Problem polega na tym, że kompilator Kotlin narzeka z "niejednoznacznością rozdzielczości przeładowania" dla wbudowanej lambda.

class Foo(){ 
    companion object Factory { 
     fun create(x: Int, f: (Int) -> Double) = 2.0 
     fun create(x: Int, f: (Int) -> Int) = 1 
    } 
} 

fun main(args:Array<String>){ 
    val a = Foo.create(1,::fromDouble) //OK 
    val b = Foo.create(1,::fromInt) //OK 
    val ambiguous = Foo.create(1){i -> 1.0} //Overload resolution ambiguity? 
} 


fun fromDouble(int:Int) = 1.0 
fun fromInt(int:Int) = 1 

W jaki sposób kompilator Kotlin rozwiązuje problem przeciążenia i dlaczego liniowa wartość lambda jest niejednoznaczna?

Answer 1

Kompilator Kotlin rozwiązuje każde wyrażenie tylko jeden raz. Tak więc, gdy kompilator rozpoczyna rozdzielczość dla wyrażenia lambda, powinien znać typy argumentów lambda. Z tego powodu kompilator powinien wybrać jedną z metod createprzed zaczyna wyglądać wewnątrz lambda.

Przykład:

fun foo(f: (Int) -> Int) = 1 
fun foo(f: (String) -> String) = "" 
val bar = foo { 
    println(it) 
    5 
} 

Tutaj nie możemy wybrać jedną z funkcji foo bo nikt z nich jest bardziej szczegółowy, że inny, więc nie możemy rozpocząć rozdzielczość dla wyrażenia lambda, ponieważ nie wiemy, wpisz dla it.

W twoim przykładzie teoretycznie możliwe jest rozpoczęcie rozdzielczości dla lambda przed wyborem konkretnej funkcji, ponieważ dla wszystkich potencjalnych funkcji typy argumentów lambda są takie same. Ale jest to logika niesprawna, która może być trudna do zrealizowania.