Kotlin: ambigüedad de resolución de sobrecarga lambda y sobrecarga

Tengo un patrón de fábrica simple donde la implementación se determina a través de la resolución de sobrecarga. El problema es que el comstackdor de Kotlin se queja con "ambigüedad de resolución de sobrecarga …" para el lambda en línea.

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 

¿Cómo resuelve el comstackdor de Kotlin la resolución de sobrecarga y por qué la lambda en línea se considera ambigua?

El comstackdor de Kotlin resuelve cada expresión solo una vez. Entonces, cuando el comstackdor inicia la resolución para la expresión lambda, debe conocer los types de arguments lambda. Debido a esto, el comstackdor debe elegir uno de los methods para create antes de que comience a mirar dentro de lambda.

Ejemplo:

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

Aquí no podemos elegir una de las funciones foo porque ninguna de ellas es más específica que otra, por lo que no podemos iniciar la resolución para la expresión lambda porque no conocemos el tipo para it .

En su ejemplo, en teoría es posible iniciar la resolución para lambda antes de elegir una function en particular porque para todas las funciones posibles, los types de arguments lambda son los mismos. Pero es una lógica no trivial que podría ser difícil de implementar.