कोटलिन: इनलाइन लैम्ब्डा और ओवरलोड रिज़ॉल्यूशन अस्पष्टता

Question

मेरे पास एक साधारण फैक्ट्री पैटर्न है जहां कार्यान्वयन ओवरलोड रिज़ॉल्यूशन के माध्यम से निर्धारित किया जाता है। समस्या यह है कि कोटलिन कंपाइलर इनलाइन लैम्ब्डा के लिए "ओवरलोड रिज़ॉल्यूशन अस्पष्टता .." के साथ शिकायत करता है।

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 

कोटलिन कंपाइलर ओवरलोड रिज़ॉल्यूशन को कैसे हल करता है और इनलाइन लैम्ब्डा को अस्पष्ट क्यों माना जाता है?

Answer 1

कोटलिन कंपाइलर केवल एक बार प्रत्येक अभिव्यक्ति को हल करता है। तो जब संकलक लैम्ब्डा अभिव्यक्ति के लिए संकल्प शुरू करता है, तो उसे लैम्ब्डा तर्कों के प्रकार पता होना चाहिए। इस कंपाइलर के कारण create से पहले इसे लैम्ब्डा के अंदर देखना शुरू होता है।

उदाहरण:

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

यहाँ हम कार्यों foo से एक का चयन नहीं कर सकते क्योंकि उनमें से कोई भी एक और है कि अधिक विशिष्ट है, इसलिए हम लैम्ब्डा अभिव्यक्ति के लिए संकल्प शुरू नहीं कर सकते क्योंकि हम नहीं जानते कि it के लिए टाइप करें।

आपके उदाहरण में यह विशेष कार्य चुनने से पहले लैम्ब्डा के लिए संकल्प शुरू करना संभव है क्योंकि लैम्ब्डा तर्कों के सभी संभावित कार्यों के प्रकार समान हैं। लेकिन यह अनौपचारिक तर्क है जिसे लागू करना मुश्किल हो सकता है।