स्कैला - निहित सूची से पहले एक खाली तर्क सूची क्यों घोषित की जाती है

Question

कुछ स्थानों (उदा। Form.bindFromRequest) निहित पैरामीटर सूची से पहले एक खाली पैरामीटर सूची का उपयोग करें। क्यूं कर? आईएमएचओ, पैरामीटर स्पष्ट रूप से form.bindFromRequest()(request) में पारित होने पर अतिरिक्त कोष्ठक की आवश्यकता होने का नुकसान होता है। सुनिश्चित नहीं है कि तब लाभ क्या है?

Answer 1

पैरामीटर सूची के साथ def कोई पैरामीटर सूची वाला एक अलग प्रकार है। यह प्रत्यक्ष आमंत्रण के तहत कोई फर्क नहीं पड़ता है, लेकिन यदि आप उस विधि को किसी अन्य विधि के तर्क के रूप में पास करते हैं, तो यह करता है।

उदाहरण में, यदि आप ऐसा तरह अपने विधि को परिभाषित:

def func1 = { println("Hello"); 1 } 

आप इसे इस विधि को पारित नहीं कर सकते हैं:

def consume(f:() => Double) = // ... 

यह है के रूप में प्रकार, बस डबल है एक बहुत ही आलसी यद्यपि एक। दूसरी ओर इस समारोह ठीक काम करेगा:

def func2() = { println("Hello"); 2 } 

मैं यह नहीं कह रहा हूँ यह स्पष्ट कारण है कि वे इसे किया था, लेकिन अगर वे एक वास्तविक कारण था, यह लगभग निश्चित रूप से टाइप करने के लिए जोड़ दी जाएंगी।

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

व्यावहारिक दृष्टि से उन दोनों के बीच अंतर यह ज्यादातर जहां वे इस्तेमाल किया जा सकता करने के लिए नीचे आता है।

कॉल-बाय-वैल्यू आइटम केवल फ़ंक्शन/विधि (afaik) पर पैरामीटर सूची में उपयोग किया जा सकता है। चूंकि इसे केवल पैरामीटर सूची में ही पारित किया जा सकता है, इसलिए आप इसे एक चर में संग्रहीत नहीं कर सकते हैं और इसे एकाधिक स्थानों में उपयोग नहीं कर सकते हैं (इसे T के स्पष्ट उदाहरण में बदलने के बिना)।

और जैसा कि आप यहाँ देख सकते हैं, वे परस्पर विनिमय दर असल नहीं हैं:

scala> def f(s: => String) { println(s) } 
f: (s: => String)Unit 

scala> def s1 =() => { "Hello" } 
s1:() => String 

scala> f(s1) 
<console>:10: error: type mismatch; 
found :() => String 
required: String 
       f(s1) 
       ^

तो कल्पना मैं कॉलबैक है कि उपयोगकर्ताओं को मेरे पास से गुजरती हैं की एक सरणी स्टोर करने के लिए करना चाहता था .. मैं यहाँ => T उपयोग नहीं कर सकते :

scala> val a: Array[=> Int] = Array() 
<console>:1: error: identifier expected but '=>' found. 
     val a: Array[=> Int] = Array() 
        ^

scala> val a: Array[() => Int] = Array() 
a: Array[() => Int] = Array() 

तो अगर मैं ऐसी वस्तुओं की दुकान, और उन्हें आंतरिक रूप से चारों ओर से पारित, => T का उपयोग कर (और यह lazily का मूल्यांकन रखते हुए) करना चाहते हैं एक विकल्प नहीं है।

मुझे लगता है कि =>=> T और () => T में एक ही चीज़ के रूप में नहीं सोचना सबसे अच्छा है। आशा है इससे थोडी मदद मिलेगी।