एक समारोह तर्क

Question

मैं अतिभारित सामान्य संकलक में जिसके परिणामस्वरूप स्पष्ट पैरामीटर प्रकार जोड़ने के लिए मुझे चाहते तरीकों के साथ मेरी डीएसएल में समस्या हो रही है ले रही है अतिभारित सामान्य विधि में "पैरामीटर प्रकार मिसिंग यू":

def alpha[T](fun: Int => T): String = fun(33).toString 

def beta [T](fun: Int => T): String = fun(66).toString 
def beta [T](thunk: => T): String = thunk.toString 

alpha { _ + 11 }   // ok 
beta { _ + 22 }   // "error: missing parameter type for expanded function" 
beta { _: Int => _ + 22 } // ok... ouch. 

किसी भी मौका मैं आखिरी पंक्ति में अव्यवस्था से छुटकारा पा सकते हैं?

संपादित करें:

प्रदर्शित करने के लिए है कि अधिक भार scalac लिए दर असल एक अस्पष्टता समस्या नहीं है, यहाँ जो पूरी तरह से ठीक काम करता है बिना प्रकार पैरामीटर एक संस्करण है:

def beta(fun: Int => String): String = fun(66).reverse 
def beta(thunk: => String): String = thunk.reverse 

beta(_.toString) // ok 
beta("gaga")  // ok 

Answer 1

समस्या यह है कि Int => T भी एक प्रकार है। उदाहरण के लिए, मान लीजिए कि आप सिर्फ दूसरे beta परिभाषित:

def beta[ T ](thunk: => T) : String = thunk.toString 

और अब आप इसे करने के लिए एक समारोह Int => Int पारित:

scala> beta((_: Int) + 1) 
res0: String = <function1> 

तो, यह देखते हुए एक समारोह फिट बैठता है कि => T, और है कि आप भी Int => T है, स्कैला को यह जानना कैसा है कि आप कौन सी चाहते हैं?

scala> beta((_: String) + 11) 
res1: String = <function1> 

स्काला कैसे मान सकता है यह एक Int था: यह एक String, उदाहरण के लिए हो सकता है? उदाहरण जिन्हें आपने अधिभार प्रदर्शित करने के लिए दिखाया है, दोष नहीं है, ऐसी किसी भी चीज को प्रदर्शित न करें, क्योंकि आपने उन प्रकार के पैरामीटर से छुटकारा पा लिया है।

Answer 2

आप हो सकता है के रूप में एहसास हुआ, समस्या तब होती है क्योंकि आपके पास बीटा फ़ंक्शन ओवरलोड हो गया है। जब आप को परिभाषित:

beta { _ + 22 } 

जो बीटा है कि आप उम्मीद कर यह कहते हैं? स्कैला यह नहीं जान सकता कि _ एक Int है क्योंकि आप इसे 22 के साथ जोड़ रहे हैं। इसलिए इस विशेष उदाहरण के लिए, आपको परिभाषित करना होगा कि _ क्या है।