तर्क के बिना कार्य, स्केल

Question

def foo(x:Int, f:Unit=>Int) = println(f()) 

foo(2, {Unit => 3+4} 

//case1 
def loop:Int = 7 
foo(2, loop) //does not compile 

changing loop to 
//case 2 
def loop():Int = 7 
foo(2, loop) // does not compile 

changing loop to 
//case 3 
def loop(x:Unit): Int = 7 //changing according to Don's Comments 
foo(2,loop) // compiles and works fine 

केस 1 और केस 2 भी काम नहीं करना चाहिए? वे क्यों काम नहीं कर रहे हैं?

को परिभाषित करने foo

def foo(x:Int, y:()=>Int) 

फिर 2 काम करता है मामला नहीं बल्कि मामले के रूप में 1.

Arent वे सभी कार्य किसी भी तरह से परिभाषित करने के लिए काम करना चाहिए।

// मुझे लगता है कि() => int में foo एक खराब शैली है, y: => Int काम नहीं करता है, टिप्पणियां ??

Answer 1

एक वस्तु है स्काला निम्नलिखित बातें अलग बीच:

• कार्य/कोई पैरामीटर सूचियों ("द्वारा साथ तरीकों -name पैरामीटर "अगर एक समारोह)
• एक खाली पैरामीटर सूची के साथ कार्य एक प्रकार यूनिट के पैरामीटर के साथ
• कार्य इनमें से

कोई नहीं, बराबर हैं, हालांकि एक सुविधा के रूप स्काला आप की अनुमति देता है खाली पैरामीटर सूचियों को दूर करने के लिए। तो (संयोग से, दो खाली पैरामीटर सूचियों भी नहीं ही हैं।)

, भले ही Unit() लिखा है, यह है नहीं समारोह तर्क के रूप में एक ही कोष्ठक एक समारोह या विधि के लिए ()। इसके बजाय, () को Tuple0 के रूप में सोचें।

तो, अगर आप कहते हैं कि f: Unit => Int, तुम क्या मतलब है "च एक पैरामीटर लेता है, लेकिन यह एक सच में बोरिंग पैरामीटर है, क्योंकि यह Unit है, जो हमेशा एक ही उबाऊ Tuple0 मूल्य () होना चाहिए" है। आप जो लिख रहे हैं वह f: (Unit) => Int के लिए वास्तव में छोटा है।

यदि आप f:() => Int कहते हैं, तो आप का मतलब है कि "एफ कोई पैरामीटर नहीं लेता है और Int उत्पन्न करता है"।

यदि आप f: => Int कहते हैं, तो आप का मतलब है कि "जो भी कथन निष्पादन में देरी करता है, उसे Int मान उत्पन्न करता है जब तक हम इस कोड में इसका उपयोग नहीं करते हैं (और हर बार फिर से मूल्यांकन करते हैं)"। कार्यात्मक रूप से, यह मूल रूप से f:() => Int के समान होता है (और आंतरिक रूप से उसी Function0 वर्ग में परिवर्तित हो जाता है), लेकिन इसका एक अलग उपयोग होता है, संभावित रूप से बंद होने के अधिक कॉम्पैक्ट रूप की अनुमति देने के लिए (आप हमेशा => को कॉलिंग कोड में छोड़ देते हैं)।

Answer 2

() => इंट Function0 [इंट] है, जबकि यूनिट => इंट Function1 [यूनिट, जे] है

scala> val function0:() => Int =() => 5 
function0:() => Int = <function0> 

scala> val function1: Unit => Int = u => 5 
function1: (Unit) => Int = <function1> 

scala> function0() 
res0: Int = 5 

scala> function1("anything") 
res1: Int = 5 

scala> function1(100) 
res2: Int = 5 

scala> 

भी ध्यान रखें कि() यूनिट

की

scala> function1(()) 
res11: Int = 5 

scala> function1() 
res12: Int = 5 

scala> function1() 
res13: Int = 5 

scala> val unit =() 
unit: Unit =() 


scala> function1(unit) 
res15: Int = 5 

scala> function1 apply unit 
res16: Int = 5 

scala> 

Answer 3

मामले 1 में और इसके बाद के संस्करण 2, पाशबजाय पाश के रिटर्न मान ही foo को दूसरा तर्क के लिए जाँच की और विफल रहता है प्रकार है: इंट = यूनिट => इंट

लूप में परिवर्तन एक टाइपो है।