अमृत ​​में दो प्रकार के कार्य क्यों होते हैं?

Question

मैं अमृत सीख रहा हूँ और आश्चर्य है कि इसकी दो प्रकार की फ़ंक्शन परिभाषाएँ क्यों हैं:

• एक मॉड्यूल में परिभाषित कार्य def, जिसे उपयोग किया जाता हैmyfunction(param1, param2)
• अनाम कार्यों के साथ परिभाषित fn, का उपयोग कर कहा जाता हैmyfn.(param1, param2)

केवल दूसरे प्रकार के फ़ंक्शन को प्रथम श्रेणी की वस्तु लगती है और इसे अन्य कार्यों के लिए एक पैरामीटर के रूप में पारित किया जा सकता है। मॉड्यूल में परिभाषित एक फ़ंक्शन को एक में लपेटने की आवश्यकता होती है fn। कुछ संश्लिष्ट चीनी होती है जो देखने otherfunction(myfunction(&1, &2))में आसान लगती है, लेकिन यह पहली जगह में क्यों आवश्यक है? हम सिर्फ क्यों नहीं कर सकते otherfunction(myfunction))? क्या यह केवल रूबी की तरह कोष्ठक के बिना मॉड्यूल फ़ंक्शन को कॉल करने की अनुमति है? ऐसा लगता है कि एरलैंग को यह विशेषता विरासत में मिली है जिसमें मॉड्यूल फ़ंक्शन और फ़न भी हैं, इसलिए क्या वास्तव में एर्लैंग वीएम आंतरिक रूप से काम करता है?

इसमें दो प्रकार के कार्य होते हैं और उन्हें अन्य कार्यों को पास करने के लिए एक प्रकार से दूसरे प्रकार में परिवर्तित करने में कोई लाभ होता है? क्या फ़ंक्शंस को कॉल करने के लिए दो अलग-अलग नोटेशन होने का कोई फ़ायदा है?

Answer 1

बस नामकरण को स्पष्ट करने के लिए, वे दोनों कार्य हैं। एक नामांकित फ़ंक्शन है और दूसरा एक अनाम है। लेकिन आप सही कह रहे हैं, वे कुछ अलग तरह से काम करते हैं और मैं यह बताने जा रहा हूं कि वे इस तरह क्यों काम करते हैं।

का दूसरा साथ शुरू करते हैं, fn। fnएक बंद है, lambdaरूबी में एक के समान है । हम इसे इस प्रकार बना सकते हैं:

x = 1
fun = fn y -> x + y end
fun.(2) #=> 3

एक फ़ंक्शन में कई खंड भी हो सकते हैं:

x = 1
fun = fn
  y when y < 0 -> x - y
  y -> x + y
end
fun.(2) #=> 3
fun.(-2) #=> 3

अब, चलो कुछ अलग करने की कोशिश करते हैं। आइए विभिन्न तर्कों की अपेक्षा विभिन्न खंडों को परिभाषित करने का प्रयास करें:

fn
  x, y -> x + y
  x -> x
end
** (SyntaxError) cannot mix clauses with different arities in function definition

अरे नहीं! हमें एक त्रुटि मिलती है! हम अलग-अलग संख्या के तर्कों की अपेक्षा कर सकते हैं। एक फ़ंक्शन में हमेशा एक निश्चित समता होती है।

अब, नामांकित कार्यों के बारे में बात करते हैं:

def hello(x, y) do
  x + y
end

जैसा कि अपेक्षित था, उनका एक नाम है और वे कुछ तर्क भी प्राप्त कर सकते हैं। हालाँकि, वे बंद नहीं हैं:

x = 1
def hello(y) do
  x + y
end

यह कोड संकलित करने में विफल हो जाएगा क्योंकि हर बार जब आप ए देखते हैं def , तो आपको एक खाली चर गुंजाइश मिलती है। यह उनके बीच एक महत्वपूर्ण अंतर है। मैं विशेष रूप से इस तथ्य को पसंद करता हूं कि प्रत्येक नामित फ़ंक्शन एक साफ स्लेट के साथ शुरू होता है और आपको अलग-अलग स्कोप के चर नहीं मिलते हैं। आपकी स्पष्ट सीमा है।

हम एक गुमनाम फ़ंक्शन के रूप में ऊपर नामित हैलो फ़ंक्शन को पुनः प्राप्त कर सकते हैं। आपने स्वयं इसका उल्लेख किया है:

other_function(&hello(&1))

और फिर आपने पूछा, मैं इसे helloअन्य भाषाओं की तरह क्यों नहीं पारित कर सकता ? ऐसा इसलिए है क्योंकि अमृत में कार्यों की पहचान नाम और गुण से होती है। तो एक फ़ंक्शन जो दो तर्कों की अपेक्षा करता है, एक अलग फ़ंक्शन है जो तीन की अपेक्षा करता है, भले ही उनका नाम एक ही हो। इसलिए अगर हम बस गुजर गए hello, तो हमें पता नहीं चलेगा कि helloआपका वास्तव में क्या मतलब है। दो, तीन या चार तर्कों वाला एक? यह वास्तव में एक ही कारण है कि हम विभिन्न प्रकारों के साथ एक अनाम फ़ंक्शन क्यों नहीं बना सकते हैं।

अमृत ​​v0.10.1 के बाद से, हमारे पास नामित कार्यों को पकड़ने के लिए एक सिंटैक्स है:

&hello/1

यह स्थानीय नामांकित फ़ंक्शन हैलो को एरीटी 1 के साथ कैप्चर करेगा। भाषा और उसके प्रलेखन के दौरान, इस hello/1सिंटैक्स में फ़ंक्शन की पहचान करना बहुत आम है ।

यही कारण है कि अमृत भी गुमनाम कार्यों को कॉल करने के लिए एक डॉट का उपयोग करता है। चूंकि आप बस helloएक फ़ंक्शन के रूप में चारों ओर से नहीं गुजर सकते हैं , इसके बजाय आपको इसे स्पष्ट रूप से कैप्चर करने की आवश्यकता है, नाम और अनाम कार्यों के बीच एक प्राकृतिक अंतर है और प्रत्येक को कॉल करने के लिए एक अलग वाक्यविन्यास सब कुछ थोड़ा अधिक स्पष्ट करता है (लिस्पर्स इससे परिचित होंगे लिस्प 1 बनाम लिस्प 2 चर्चा के कारण)।

कुल मिलाकर, वे कारण हैं जिनके कारण हमारे दो कार्य हैं और वे अलग-अलग व्यवहार क्यों करते हैं।

Comments

मैं एलिक्सिर भी सीख रहा हूं, और यह पहला मुद्दा है जिसका मुझे सामना करना पड़ा जिसने मुझे विराम दिया, इसके बारे में कुछ बस असंगत लग रहा था। महान स्पष्टीकरण, लेकिन स्पष्ट होना ... क्या यह एक कार्यान्वयन मुद्दे का परिणाम है, या क्या यह कार्यों के उपयोग और पारित होने के बारे में गहन ज्ञान को दर्शाता है? चूंकि अनाम फ़ंक्शन तर्क मानों के आधार पर मेल कर सकते हैं, ऐसा लगता है कि यह तर्कों की संख्या पर मिलान करने में सक्षम होने के लिए भी उपयोगी होगा (और फ़ंक्शन पैटर्न कहीं और मेल खाता है)।

— चक्रवात

यह इस अर्थ में एक कार्यान्वयन बाधा नहीं है कि यह f()(डॉट के बिना) के रूप में भी काम कर सकता है ।

— जोस वेलिम

आप is_function/2एक गार्ड का उपयोग करके तर्कों की संख्या पर मेल कर सकते हैं । is_function(f, 2)यह जाँच करता है कि यह 2. की है। :)

— जोस वैलिम

मैंने नाम और अनाम फ़ंक्शन दोनों के लिए डॉट्स के बिना फ़ंक्शन इनवोकेशन को प्राथमिकता दी होगी। यह कभी-कभी भ्रमित कर देता है और आप भूल जाते हैं कि क्या कोई विशेष फ़ंक्शन अनाम था या नाम दिया गया था। वहाँ भी अधिक शोर है जब यह करी की बात आती है।

— CMCDragonkai

एरलैंग में, अनाम फ़ंक्शन कॉल और नियमित फ़ंक्शन पहले से ही वाक्यात्मक रूप से भिन्न हैं: SomeFun()और some_fun()। अमृत ​​में, यदि हमने डॉट को हटा दिया, तो वे समान होंगे some_fun()और some_fun()क्योंकि चर समान फ़ंक्शन नाम के समान पहचानकर्ता का उपयोग करते हैं। इसलिए बिंदी।

— जोस वलीम

Answer 2

मुझे नहीं पता कि यह किसी और के लिए कितना उपयोगी होगा, लेकिन जिस तरह से मैंने अंत में अवधारणा के चारों ओर अपना सिर लपेटा था, वह यह महसूस करना था कि अमृत फ़ंक्शन कार्यात्मक नहीं हैं।

अमृत ​​में सब कुछ एक अभिव्यक्ति है। इसलिए

MyModule.my_function(foo) 

एक फ़ंक्शन नहीं है लेकिन कोड को निष्पादित करके अभिव्यक्ति वापस आ गई है my_function । वास्तव में "फ़ंक्शन" प्राप्त करने का केवल एक ही तरीका है कि आप एक तर्क के रूप में चारों ओर से गुजर सकते हैं और वह है अनाम फ़ंक्शन नोटेशन का उपयोग करना।

यह फ़ंक्शन सूचक के रूप में fn या & संकेतन को संदर्भित करने के लिए आकर्षक है, लेकिन यह वास्तव में बहुत अधिक है। यह आसपास के वातावरण का बंद होना है।

यदि आप खुद से पूछें:

क्या मुझे इस मौके में एक निष्पादन पर्यावरण या डेटा मूल्य की आवश्यकता है?

और अगर आपको निष्पादन के उपयोग की आवश्यकता है fn, तो अधिकांश कठिनाइयाँ अधिक स्पष्ट हो जाती हैं।

Comments

यह स्पष्ट है कि MyModule.my_function(foo)एक अभिव्यक्ति है लेकिन MyModule.my_function" एक अभिव्यक्ति " हो सकता है जो एक फ़ंक्शन "ऑब्जेक्ट" देता है। लेकिन चूँकि आपको आर्इटी बताने की ज़रूरत है, इसलिए आपको MyModule.my_function/1इसके बदले कुछ चाहिए होगा । और मुझे लगता है कि उन्होंने फैसला किया &MyModule.my_function(&1) कि इसके बजाय एक वाक्यविन्यास का उपयोग करना बेहतर था जो कि धमनी को व्यक्त करने की अनुमति देता है (और अन्य उद्देश्यों की भी सेवा करता है)। फिर भी स्पष्ट नहीं है कि ()नामित कार्यों के .()लिए एक ऑपरेटर और अनाम कार्यों के लिए एक ऑपरेटर क्यों है

— रुबेनलागुना

मुझे लगता है कि आप चाहते हैं: &MyModule.my_function/1कि आप इसे एक समारोह के रूप में कैसे पारित कर सकते हैं।

— jnmandal

Answer 3

मुझे कभी समझ नहीं आया कि इसके स्पष्टीकरण इतने जटिल क्यों हैं।

यह वास्तव में रूबी-शैली की वास्तविकता के साथ संयुक्त रूप से केवल एक असाधारण छोटा सा अंतर है "बिना परिजनों के कार्य निष्पादन"।

की तुलना करें:

def fun1(x, y) do
  x + y
end

सेवा:

fun2 = fn
  x, y -> x + y
end

जबकि ये दोनों सिर्फ पहचानकर्ता हैं ...

• fun1एक पहचानकर्ता है जो एक नामित फ़ंक्शन का वर्णन करता है जिसके साथ परिभाषित किया गया है def।
• fun2 एक पहचानकर्ता है जो एक चर का वर्णन करता है (जो फ़ंक्शन के संदर्भ में होता है)।

विचार करें कि जब आप देखते हैं fun1या fun2किसी अन्य अभिव्यक्ति में इसका क्या अर्थ है ? उस अभिव्यक्ति का मूल्यांकन करते समय, क्या आप संदर्भित फ़ंक्शन को कॉल करते हैं या क्या आप स्मृति से बाहर एक मूल्य का संदर्भ देते हैं?

संकलन समय पर पता करने का कोई अच्छा तरीका नहीं है। रूबी के पास वैरिएबल नेमस्पेस को इंट्रोस्पेक्ट करने का लक्जरी है ताकि यह पता लगाया जा सके कि किसी समय में एक वैरिएबल बाइंडिंग ने किसी फ़ंक्शन को छायांकित किया है या नहीं। संकलित किया जा रहा अमृत वास्तव में ऐसा नहीं कर सकता। यह डॉट-नोटेशन क्या करता है, यह अमृत बताता है कि इसमें एक फ़ंक्शन संदर्भ होना चाहिए और इसे कॉल किया जाना चाहिए।

और यह वास्तव में कठिन है। कल्पना कीजिए कि कोई डॉट नोटेशन नहीं था। इस कोड पर विचार करें:

val = 5

if :rand.uniform < 0.5 do
  val = fn -> 5 end
end

IO.puts val     # Does this work?
IO.puts val.()  # Or maybe this?

उपरोक्त कोड को देखते हुए, मुझे लगता है कि यह स्पष्ट है कि आपको अमृत क्यों देना है। कल्पना कीजिए कि क्या प्रत्येक चर-संदर्भ को किसी फ़ंक्शन के लिए जांचना था? वैकल्पिक रूप से, कल्पना कीजिए कि क्या हीरोइनों को हमेशा यह पता लगाने के लिए आवश्यक होगा कि चर अनुमेय एक फ़ंक्शन का उपयोग कर रहा था?

Answer 4

मैं गलत हो सकता हूं क्योंकि किसी ने भी इसका उल्लेख नहीं किया है, लेकिन मैं इस धारणा के तहत भी था कि इसका कारण भी कोष्ठक के बिना कार्यों को कॉल करने में सक्षम होने की रूबी विरासत है।

एरियर स्पष्ट रूप से शामिल है, लेकिन इसे थोड़ी देर के लिए अलग रख देता है और बिना तर्क के कार्यों का उपयोग करता है। जावास्क्रिप्ट जैसी भाषा में जहां कोष्ठक अनिवार्य हैं, फ़ंक्शन को तर्क के रूप में पारित करने और फ़ंक्शन को कॉल करने के बीच अंतर करना आसान है। आप इसे केवल तब कहते हैं जब आप कोष्ठक का उपयोग करते हैं।

my_function // argument
(function() {}) // argument

my_function() // function is called
(function() {})() // function is called

जैसा कि आप देख सकते हैं, इसका नामकरण करना या न करना एक बड़ा अंतर नहीं है। लेकिन अमृत और माणिक आपको ब्रैकेट्स के बिना फ़ंक्शन को कॉल करने की अनुमति देते हैं। यह एक डिज़ाइन विकल्प है जो मुझे व्यक्तिगत रूप से पसंद है लेकिन इसका यह दुष्प्रभाव है कि आप बिना कोष्ठक के सिर्फ नाम का उपयोग नहीं कर सकते क्योंकि इसका मतलब हो सकता है कि आप फ़ंक्शन को कॉल करना चाहते हैं। यह वही &है जिसके लिए है। यदि आप एक दूसरे के लिए एरिटी एपार्ट को छोड़ते हैं, तो अपने फ़ंक्शन नाम को &इस तरह से प्रस्तुत करने का मतलब है कि आप स्पष्ट रूप से इस फ़ंक्शन को एक तर्क के रूप में उपयोग करना चाहते हैं, न कि यह फ़ंक्शन वापस आता है।

अब अनाम फ़ंक्शन थोड़ा अलग है कि इसका उपयोग मुख्य रूप से एक तर्क के रूप में किया जाता है। फिर से यह एक डिजाइन विकल्प है लेकिन इसके पीछे तर्कसंगत यह है कि इसका उपयोग मुख्य रूप से पुनरावृत्तियों के प्रकारों द्वारा किया जाता है जो कार्यों को तर्क के रूप में लेते हैं। तो जाहिर है आप का उपयोग करने की जरूरत नहीं है &क्योंकि वे पहले से ही डिफ़ॉल्ट रूप से तर्क माना जाता है। यह उनका उद्देश्य है।

अब अंतिम समस्या यह है कि कभी-कभी आपको उन्हें अपने कोड में कॉल करना होगा, क्योंकि वे हमेशा इट्रेटर प्रकार के फ़ंक्शन के साथ उपयोग नहीं किए जाते हैं, या आप स्वयं एक इटेरिक कोडिंग कर सकते हैं। छोटी कहानी के लिए, चूंकि माणिक ऑब्जेक्ट ओरिएंटेड है, ऐसा करने का मुख्य तरीका callऑब्जेक्ट पर विधि का उपयोग करना था । इस तरह, आप गैर-अनिवार्य कोष्ठक व्यवहार को सुसंगत रख सकते हैं।

my_lambda.call
my_lambda.call()
my_lambda_with_arguments.call :h2g2, 42
my_lambda_with_arguments.call(:h2g2, 42)

अब किसी के पास एक शॉर्टकट आया, जो मूल रूप से बिना नाम वाला एक तरीका है।

my_lambda.()
my_lambda_with_arguments.(:h2g2, 42)

फिर, यह एक डिजाइन विकल्प है। अब अमृत वस्तु उन्मुख नहीं है और इसलिए कॉल को सुनिश्चित करने के लिए पहले फ़ॉर्म का उपयोग न करें। मैं जोस के लिए नहीं बोल सकता लेकिन ऐसा लगता है कि अमृत में दूसरे रूप का उपयोग किया गया था क्योंकि यह अभी भी एक अतिरिक्त चरित्र के साथ एक फ़ंक्शन कॉल की तरह दिखता है। यह एक फ़ंक्शन कॉल के लिए पर्याप्त है।

मैंने सभी पेशेवरों और विपक्षों के बारे में नहीं सोचा था, लेकिन ऐसा लगता है कि दोनों भाषाओं में आप केवल कोष्ठक के साथ दूर हो सकते हैं जब तक आप अनाम कार्यों के लिए कोष्ठक को अनिवार्य बनाते हैं। ऐसा लगता है कि यह है:

अनिवार्य कोष्ठक वी.एस. थोड़ा अलग संकेतन

दोनों मामलों में आप एक अपवाद बनाते हैं क्योंकि आप दोनों अलग व्यवहार करते हैं। चूंकि एक अंतर है, आप इसे स्पष्ट कर सकते हैं और अलग-अलग अंकन के लिए जा सकते हैं। अनिवार्य कोष्ठक ज्यादातर मामलों में स्वाभाविक दिखेंगे, लेकिन जब योजना के अनुसार चीजें नहीं होती हैं तो बहुत भ्रमित होते हैं।

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

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

वैसे भी ... यह दायरे से बाहर है।

Answer 5

इस व्यवहार के बारे में एक उत्कृष्ट ब्लॉग पोस्ट है: लिंक

दो प्रकार के कार्य

यदि एक मॉड्यूल में यह शामिल है:

fac(0) when N > 0 -> 1;
fac(N)            -> N* fac(N-1).

आप इसे केवल शेल में काट और पेस्ट नहीं कर सकते और समान परिणाम प्राप्त कर सकते हैं।

ऐसा इसलिए है क्योंकि एर्लांग में एक बग है। Erlang में मॉड्यूल FORMS के क्रम हैं । Erlang खोल के एक दृश्य का मूल्यांकन करता है अभिव्यक्ति । Erlang में फॉर्म नहीं हैं अभिव्यक्ति ।

double(X) -> 2*X.            in an Erlang module is a FORM

Double = fun(X) -> 2*X end.  in the shell is an EXPRESSION

दोनो एक जैसे नहीं हैं। यह खटास हमेशा के लिए मिट गई लेकिन हमने इसे नोटिस नहीं किया और हमने इसके साथ रहना सीख लिया।

कॉलिंग में डॉट fn

iex> f = fn(x) -> 2 * x end
#Function<erl_eval.6.17052888>
iex> f.(10)
20

स्कूल में मैंने f (10) नॉट एफ (10) लिखकर फंक्शन कॉल करना सीखा। यह "वास्तव में" है, जिसका कार्य Shell.f (10) जैसे नाम के साथ है (यह शेल में परिभाषित एक फ़ंक्शन है) शेल भाग है निहित तो यह सिर्फ एफ (10) कहा जाना चाहिए।

यदि आप इसे इस तरह से छोड़ देते हैं कि आप अपने जीवन के अगले बीस वर्षों को खर्च करने की उम्मीद करते हैं तो क्यों।

Comments

मैं सीधे ओपी प्रश्न का उत्तर देने में उपयोगिता के बारे में सुनिश्चित नहीं हूं, लेकिन लिंक (टिप्पणी अनुभाग सहित) वास्तव में प्रश्न के लक्षित दर्शकों के लिए एक महान पढ़ा आईएमओ है, अर्थात हम में से जो अमृत और एर्लैंग सीखने के लिए नए हैं। ।

लिंक अब मृत है :(

— अनिलरेडशिफ्ट

Answer 6

अमृत ​​में 0 एरिटी वाले कार्यों सहित कार्यों के लिए वैकल्पिक ब्रेसेस हैं। आइए एक उदाहरण देखें कि यह अलग कॉलिंग सिंटैक्स को महत्वपूर्ण क्यों बनाता है:

defmodule Insanity do
  def dive(), do: fn() -> 1 end
end

Insanity.dive
# #Function<0.16121902/0 in Insanity.dive/0>

Insanity.dive() 
# #Function<0.16121902/0 in Insanity.dive/0>

Insanity.dive.()
# 1

Insanity.dive().()
# 1

2 प्रकार के कार्यों के बीच अंतर किए बिना, हम यह नहीं कह सकते कि Insanity.diveइसका क्या अर्थ है: स्वयं एक फ़ंक्शन प्राप्त करना, इसे कॉल करना, या परिणामी अनाम फ़ंक्शन को कॉल करना।

Answer 7

fn ->सिंटैक्स अनाम फ़ंक्शंस का उपयोग करने के लिए है। Doing var!) (केवल अमृत बता रहा है कि मैं चाहता हूं कि आप उस var को इसमें एक func के साथ लें और var को संदर्भित करने के बजाय इसे रन करें क्योंकि कुछ उस फ़ंक्शन को पकड़े हुए है।

अमृत ​​का यह एक सामान्य पैटर्न है जहां किसी फ़ंक्शन के अंदर तर्क रखने के बजाय यह देखने के लिए कि किसी चीज़ को कैसे निष्पादित किया जाना चाहिए, हम किस प्रकार के इनपुट के आधार पर विभिन्न कार्यों से मेल खाते हैं। मेरा मानना ​​है कि इसीलिए हम function_name/1अर्थ में चीजों को संदर्भित करते हैं ।

शॉर्टहैंड फंक्शन डेफिनिशन (फंक (& 1), आदि) करने की आदत होने के लिए यह अजीब तरह का है, लेकिन जब आप अपने कोड को पाइप करने या रखने की कोशिश कर रहे हों तो यह आसान है।

Answer 8

केवल दूसरे प्रकार के फ़ंक्शन को प्रथम श्रेणी की वस्तु लगती है और इसे अन्य कार्यों के लिए एक पैरामीटर के रूप में पारित किया जा सकता है। मॉड्यूल में परिभाषित एक फ़ंक्शन को fn में लपेटने की आवश्यकता होती है। कुछ संश्लिष्ट चीनी होती है जो देखने otherfunction(myfunction(&1, &2))में आसान लगती है, लेकिन यह पहली जगह में क्यों आवश्यक है? हम सिर्फ क्यों नहीं कर सकते otherfunction(myfunction))?

तुम कर सकते हो otherfunction(&myfunction/2)

चूंकि अमृत कोष्ठक (जैसे myfunction) के बिना कार्यों को निष्पादित कर सकता है , otherfunction(myfunction))इसलिए इसका उपयोग निष्पादित करने का प्रयास करेगा myfunction/0।

इसलिए, आपको कैप्चर ऑपरेटर का उपयोग करने और फ़ंक्शन को निर्दिष्ट करने की आवश्यकता है, जिसमें एरिटी भी शामिल है, क्योंकि आपके पास एक ही नाम के साथ अलग-अलग फ़ंक्शन हो सकते हैं। इस प्रकार, &myfunction/2।