फंक्शन तर्क कई प्रकार

Question

मैं विभिन्न गणनाओं में देरी करने की कोशिश कर रहा हूं। मैं निम्न रूप में कार्य करता है,

(defn a-fn [a b] 
    (let [a (if (fn? a) 
      a 
      #(identity a)) 

     b (if (fn? b) 
      b 
      #(identity b))] 
    (+ (a) (b)))) 

यह मेरे पास करने के लिए एक-fn, एक मूल्य या एक समारोह है कि मान देता है,

(a-fn 1 2)  
(defn x [] 1)  
(defn y [] 2)  
(a-fn x y) 
(a-fn x 2) 

मैं क्या कार्यों की एक सूची का निर्माण होता है की अनुमति देता है (उपर्युक्त की तरह) कुछ डेटा पर काम करने के लिए, एफएनएस अपने तर्कों को पुनः प्राप्त करने के लिए अन्य एफएनएस का उपयोग कर सकते हैं या कुछ मामलों में चीजें बदलती नहीं हैं और उन्हें मूल्यों को तर्क के रूप में असाइन किया जाता है। मैं सोच रहा था कि इस तरह के व्यवहार को प्राप्त करने का एक बेहतर तरीका है?

Answer 1

आप क्या चाहते करने के लिए एक और अधिक सुरुचिपूर्ण तरीका नहीं हो सकता है, लेकिन यहाँ कम से कम इसके बारे में एक अधिक सामान्य संस्करण है:

(defn delayed [reducer & fs] 
    (apply reducer (for [f fs] (if (fn? f) (f) f)))) 

(def a-fn (partial delayed +)) 

तो delayed एक मनमाना समारोह और समारोह/मानों की सूची लेता है। यदि सभी तर्कों का विस्तार होता है और फिर उन्हें कार्य लागू करता है। फिर हम + का उपयोग कर अपने a-fn परिभाषित करने के लिए partial का उपयोग करें:

user=> (a-fn 1 2) 
3 
user=> (a-fn (constantly 1) 2) 
3 
user=> (a-fn (constantly 1) 2 4) 
7 

वैकल्पिक रूप से, यह delayed के लिए कोई मतलब हो सकता है आंशिक उपयोग करने के बजाय एक समारोह वापस जाने के लिए। ध्यान दें कि कौन सा बेहतर है।

की तुलना में "देरी" एक बेहतर नाम स्वागत :)

Answer 2

आप delay और force का उपयोग कर सकते है:

user=> (defn a-fn [a b] (+ (force a) (force b))) 
#'user/a-fn 
user=> (a-fn 1 2) 
3 
user=> (def x (delay 1)) 
#'user/x 
user=> (def y (delay 2)) 
#'user/y 
user=> (a-fn x y) 
3 
user=> (a-fn x 2) 
3 

आप जब गणना किया जाता है परीक्षण करने के लिए (delay (prn :hello) 1) की तरह कुछ की कोशिश करते हैं, तो ध्यान दें कि मुद्रण देरी वस्तु इसे बल देती है; इसलिए (def x (delay ...)) सुरक्षित है, लेकिन REPL संकेत में एक सादा (delay ...) टाइप करना नहीं है।