अनाम फ़ंक्शन शॉर्टहैंड

Question

कुछ ऐसी बातें हैं जो मुझे लघु संकेतन # (..) का उपयोग करते हुए अनाम कार्यों के बारे में समझ में नहीं आती हैं

निम्नलिखित कार्य:

REPL>  ((fn [s] s) "Eh")
"Eh"

लेकिन यह नहीं है:

REPL>  (#(%) "Eh")

यह काम:

REPL> (#(str %) "Eh")
"Eh"

क्या मुझे समझ नहीं आता क्यों है (# (%) "एह") काम नहीं करता है और एक ही समय में मैं का उपयोग करने की जरूरत नहीं है str में ((एफ एन [एस] रों) "एह")

वे दोनों अनाम कार्य कर रहे हैं और वे दोनों, यहाँ, एक पैरामीटर लेते हैं। शॉर्टहैंड नोटेशन को फ़ंक्शन की आवश्यकता क्यों होती है जबकि अन्य नोटेशन को नहीं?

Answer 1

#(...)

के लिए आशुलिपि है

(fn [arg1 arg2 ...] (...))

(जहाँ argN की संख्या इस बात पर निर्भर करती है कि आपके शरीर में कितने% N है)। इसलिए जब आप लिखते हैं:

#(%)

इसका अनुवाद इस प्रकार है:

(fn [arg1] (arg1))

ध्यान दें कि यह आपके पहले अनाम फ़ंक्शन से अलग है, जो इस प्रकार है:

(fn [arg1] arg1)

आपका संस्करण एक मान के रूप में arg1 देता है, शॉर्टहैंड का विस्तार करने से आने वाला संस्करण इसे फ़ंक्शन के रूप में कॉल करने का प्रयास करता है। आपको एक त्रुटि मिलती है क्योंकि एक स्ट्रिंग एक मान्य फ़ंक्शन नहीं है।

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

Answer 2

जैसा कि अन्य उत्तर पहले ही बहुत स्पष्ट रूप से बता चुके हैं, #(%)आपने वास्तव में कुछ इस तरह का विस्तार किया है (fn [arg1] (arg1)), जो बिल्कुल भी समान नहीं है (fn [arg1] arg1)।

@ जॉन फ्लैटनेस ने कहा कि आप बस उपयोग कर सकते हैं identity, लेकिन यदि आप प्रेषण मैक्रो identityका उपयोग करके लिखने का तरीका ढूंढ रहे हैं, तो आप #(...)इसे इस तरह कर सकते हैं:

#(-> %)

#(...)प्रेषण मैक्रो को ->थ्रेडिंग मैक्रो के साथ जोड़कर इसे कुछ इस तरह विस्तारित किया जाता है (fn [arg1] (-> arg1)), जो फिर से फैलता है (fn [arg1] arg1), जो कि आप चाहते हैं। मैं भी सरल कार्यों को लिखने के लिए सहायक ->और #(...)स्थूल कॉम्बो पाता हूं जो वैक्टर लौटाते हैं, जैसे:

#(-> [%2 %1])

Answer 3

जब आप का उपयोग #(...), आप कल्पना कर सकते आप के बजाय लिख रहे हैं (fn [args] (...)), सहित कोष्ठकों आप सही पाउंड के बाद शुरू कर दिया।

तो, आपका गैर-काम करने वाला उदाहरण निम्न में परिवर्तित होता है:

((fn [s] (s)) "Eh")

जो स्पष्ट रूप से काम नहीं करता है क्योंकि आप स्ट्रिंग "एह" को कॉल करने की कोशिश कर रहे हैं । strकार्यों के साथ आपका उदाहरण क्योंकि अब आपका कार्य (str s)इसके बजाय है (s)। (identity s)यह आपके पहले उदाहरण के सबसे करीब एनालॉग होगा, क्योंकि यह str के लिए मजबूर नहीं करेगा।

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