clojure: (एफ एन coll लागू) बनाम (लागू # (लागू fn% और) coll)

Question

मैं labrepl के माध्यम से अपने रास्ते काम कर रहा हूँ और मैं कुछ कोड है कि इस पद्धति का अनुसरण करता देखा:

;; Pattern 
(apply #(apply f %&) coll) 

;; Concrete example 
user=> (apply #(apply + %&) [1 2 3 4]) 
10 

यह प्रतीत हो रहा है इस पैटर्न के बराबर:

;; Pattern 
(apply f coll) 

;; Concrete example 
user=> (apply + [1 2 3 4]) 
10 

क्या ये पैटर्न समकक्ष हैं? यदि नहीं, तो क्या अंतर है और आप दूसरे पर एक का उपयोग कब करेंगे?

मैं labrepl के सेलुलर-ऑटोमेटा प्रयोगशाला में step function से पूर्व पैटर्न ले लिया:

(defn step 
    "Advance the automation by one step, updating all cells." 
    [board] 
    (doall 
    (map (fn [window] 
      (apply #(apply map brians-brain-rules %&) 
       (doall (map torus-window window)))) 
     (torus-window board)))) 

अद्यतन: मैं मदद करने के लिए सवाल स्पष्ट करने के लिए प्रत्येक पैटर्न की एक ठोस उदाहरण गयी।

Answer 1

नहीं, इसमें कोई फर्क नहीं पड़ता। लंबा फॉर्म लिखने का कोई कारण नहीं है; मैं केवल यह मान सकता हूं कि यह कोड में क्रमिक परिवर्तनों से आया था जो एक समय में समझ में आया था।

Answer 2

अनिवार्य रूप से, दोनों रूप एक ही चीज़ को पूरा करते हैं और कम या कम होते हैं। प्रत्येक एक अज्ञात समारोह शुरू करने का एक तरीका प्रदान करता है।

#(... का उपयोग एक अज्ञात फ़ंक्शन के लिए क्लोजर रीडर शॉर्टैंड है। यह (fn [arg1 & args]... के बराबर है, लेकिन आप एक #(... किसी अन्य के अंदर अज्ञात फ़ंक्शन को एम्बेड नहीं कर सकते हैं, और वेक्टर बाध्यकारी (fn [arg & args] के बजाय तर्क % %2... या %1 %2... के रूप में व्यक्त किए जाते हैं।

दोनों अज्ञात फ़ंक्शन को व्यक्त करने के तरीके हैं। #(... सरल कार्यों के लिए उपयोग किया जाता है, और (fn... का उपयोग अधिक विस्तृत कार्यों के लिए किया जाता है।

#(... चीजों को थोड़ा साफ दिखने के लिए प्रेरित करता है।