एकाधिक पैरामीटर क्लोजर तर्क प्रकार अनुमानित नहीं है

Question

मेरे पास कोड का एक टुकड़ा है जिसे मैं जिस तरह से व्यवहार करना चाहता हूं उससे व्यवहार नहीं कर सकता। मैं एक वर्ग नीचे दिए तरीक़े (इस के लिए नीचे छीन) में परिभाषित किया गया है:

class Behaviour[T](private val rule: Time => T) { 
    def map1[U, V](behaviour: Behaviour[U], func: (T, U) => V): Behaviour[V] = { 
    new Behaviour(time => func(this.at(time), behaviour.at(time))) 
    } 
} 

जब इस वर्ग मैं कुछ है कि मैंने सोचा था कि तुच्छ होगा करने की कोशिश की के साथ प्रयोग करना:

val beh = Behaviour(time => 5) 
val beh2 = Behaviour(time => 5) 
beh.map1(beh2, (a, b) => a + b) 

पिछले के लिए लाइन मैं निम्न त्रुटि प्राप्त:

<console>:13: error: missing parameter type 
      beh.map1(beh2, (a, b) => a + b) 
          ^

मैं निश्चित रूप से बंद पैरामीटर प्रकार निर्दिष्ट कर सकते हैं और इसे सही ढंग से काम करता है लेकिन क्यों यहाँ अनुमान काम टाइप नहीं करता है? बेशक मैं फ़ंक्शन के लिए जेनेरिक प्रकार भी निर्दिष्ट कर सकता हूं (दोनों समाधानों के लिए नीचे देखें)।

मैंने सोचा था कि स्केल ने अनुमानित प्रकारों के लिए 'स्कैन' किया था और beh2 देखेंगे और फ़ंक्शन में पास हो जाएगा और होने के लिए U मान लेंगे। क्या इनपुट तरीका पैरामीटर के प्रकार (बंद या जेनेरिक के लिए) निर्दिष्ट किए बिना मैं इसे ठीक कर सकता हूं?

संपादित करें: दो फिक्स मेरे पास है, इसके उदाहरण:

beh.map1[Int, Int](beh2, (a, b) => a + b) 
beh.map1(beh2, (a, b : Int) => a + b) 

Answer 1

this scala-debate thread देखें कि यहां क्या हो रहा है इसकी चर्चा के लिए। समस्या यह है कि स्कैला का प्रकार अनुमान पैरामीटर सूची होता है, प्रति पैरामीटर पर नहीं।

जोश सुएरेथ उस धागे में नोट करते हैं, वर्तमान दृष्टिकोण के लिए एक अच्छा कारण है। यदि स्कैला प्रति-पैरामीटर प्रकार अनुमान था, तो संकलक एक ही पैरामीटर सूची में ऊपरी बाउंड प्रकारों का अनुमान नहीं लगा सकता था। निम्नलिखित पर विचार करें:

trait X 
class Y extends X 
class Z extends X 

val y = new Y 
val z = new Z 

def f[A](a: A, b: A): (A, A) = (a, b) 
def g[A](a: A)(b: A): (A, A) = (a, b) 

f(y, z) वास्तव में काम करता है के रूप में हम उम्मीद थी, लेकिन g(y)(z) समय संकलक दूसरा तर्क सूची यह पहले से ही YA के लिए प्रकार के रूप में चुना गया है करने के लिए हो जाता है के द्वारा एक प्रकार मेल नहीं खाता देता है, के बाद से।

Answer 2

तरीके इसे ठीक करने में से एक कई तर्क सूचियां निर्धारित करने के लिए है।

def map1[U, V](behaviour: Behaviour[U])(func: (T, U) => V): Behaviour[V] = ... 

और आप इस तरह इसका इस्तेमाल कर सकते हैं:: तो अपने map1 विधि इस तरह परिभाषित किया जाएगा

beh.map1(beh2)((a, b) => a + b) 
beh.map1(beh2)(_ + _) 

मैं पूरी तरह से यकीन है कि क्यों प्रकार निष्कर्ष अपने मामले में काम नहीं करता नहीं हूँ, लेकिन मैं मान लें कि U प्रकार पैरामीटर के उपयोग के साथ इसका कुछ संबंध है। आप इसे दो बार उपयोग कर रहे हैं - पहले और दूसरे तर्क के लिए। संकलक के लिए इसे समझने के लिए शायद यह बहुत जटिल है। 2 तर्क सूचियों के मामले में, U पहले तर्क सूची संकलन के दौरान अनुमान लगाया जाएगा, और दूसरी तर्क सूची पहले से अनुमानित प्रकार का उपयोग करेगी।