कॉलिंग/लागू लैम्ब्डा बनाम फ़ंक्शन कॉल - रुबी में सिंटैक्स अलग है। क्यूं कर?

Question

मैं रूबी के लिए थोडा नया हूं और अभी भी कुछ भाषा डिजाइन सिद्धांतों को समझने की कोशिश कर रहा हूं। अगर मुझे यह सही हो गया है, रूबी में लैम्ब्डा अभिव्यक्ति कॉल स्क्वायर ब्रेसिज़ के साथ होना चाहिए, जबकि "नियमित" फ़ंक्शन कॉल "नियमित"/गोल ब्रेसिज़ के साथ है।

क्या कोई विशेष कारण है कि वाक्यविन्यास अलग है? या, दूसरे शब्दों में, (क्यों) कॉलर को पता होना चाहिए कि क्या वे कोई फ़ंक्शन कॉल करते हैं या लैम्ब्डा अभिव्यक्ति लागू करते हैं?

Answer 1

क्योंकि रूबी में, विधियां lambdas नहीं हैं (उदाहरण के लिए, जावास्क्रिप्ट में)।

तरीके हमेशा वस्तुओं से संबंधित होते हैं, विरासत में प्राप्त किया जा सकता है (उप-वर्गीकरण या मिश्रित द्वारा), किसी ऑब्जेक्ट के ईजेनक्लास में ओवरराइट किया जा सकता है और इसे एक ब्लॉक (जो लैम्ब्डा है) दिया जा सकता है। वे चर के लिए अपना खुद का दायरा है। उदाहरण विधि परिभाषा:

a = :some_variable 
def some_method 
    # do something, but not possible to access local variable a 
end 

# call with: 
some_method 

हालांकि lambdas/procs सादा बंद किया जाना, शायद एक चर में संग्रहीत हैं - और कुछ नहीं:

a = :some_variable 
some_lambda = lambda{ 
    # do something, access local variable a if you want to 
} 

# call with: 
some_lambda[] 

रूबी को जोड़ती है दोनों, एक शक्तिशाली वाक्य रचना के साथ दृष्टिकोण उदाहरण के लिए, ब्लॉक गुजर:

def some_method_with_block(a) 
    # do something, call given block (which is a lambda) with: 
    yield(a) ? 42 : 21 
end 

# example call: 
some_method_with_block(1) do |x| 
    x.odd? 
end #=> 42 

Answer 2

नियमित रूबी विधि कॉल () कॉल करने के लिए घुंघराले ब्रेसिज़ का उपयोग नहीं करते हैं। यदि आपको लैम्ब्डा कॉल करने के लिए [] पसंद नहीं है, तो आप हमेशा call विधि का उपयोग कर सकते हैं।

उदाहरण:

>> by_two = lambda { |x| x * 2 } #=> #<Proc:0x0000000101304588@(irb):1> 
>> by_two[5] #=> 10 
>> by_two.call(5) #=> 10 

संपादित

भी रूबी के नए संस्करण में:

>> by_two.(5) #=> 10 

क्यों तुम सिर्फ by_two(5) ऐसा नहीं कर सकते, जब रूबी एक bareword देखता है के रूप में यह पहले इसे स्थानीय चर के रूप में हल करने का प्रयास करता है और यदि वह किसी विधि के रूप में विफल रहता है।

Answer 3

आप कोष्ठक चाहते हैं, आप कर सकते हैं

by_two = lambda { |x| x * 2 } 
by_two.(5) # => 10 

.by_two और (5) के बीच नोट करें।