Kotlin: lambda in linea e ambiguità della risoluzione di sovraccarico

Question

Ho un modello di fabbrica semplice in cui l'implementazione viene determinata tramite la risoluzione di sovraccarico. Il problema è che il compilatore Kotlin si lamenta con "Ambiguità della risoluzione di sovraccarico .." per il lambda in linea.

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 

Come funziona la risoluzione di sovraccarico compilatore risolvere Kotlin e perché è il lambda linea considerata ambigua?

Answer 1

Il compilatore Kotlin risolve ogni espressione solo una volta. Quindi, quando il compilatore inizia la risoluzione per l'espressione lambda, dovrebbe conoscere i tipi di argomenti lambda. A causa di questo compilatore dovrebbe scegliere uno dei metodi createprima dello inizia a guardare dentro lambda.

Esempio:

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

Qui non possiamo scegliere una delle funzioni foo perché nessuno di loro è più specifico che un altro, quindi non possiamo iniziare a risoluzione per l'espressione lambda, perché non sappiamo digitare per it.

Nel tuo esempio è in teoria possibile avviare la risoluzione per lambda prima di scegliere una funzione particolare perché per tutte le potenziali funzioni i tipi di argomenti lambda sono gli stessi. Ma è una logica non banale che potrebbe essere difficile da implementare.