परिभाषित कम arity आंशिक कार्यों

Question

मैं कभी कभी कार्यों की कम arity संस्करणों, कि एक आंशिक समारोह लौटने के लिए, उदाहरण के लिए परिभाषित करने के लिए यह Clojure में सुविधाजनक मिल गया है

(defn prefix 
    ([pre string] 
    (str pre ":" string)) 

    ([pre] 
    (fn [string] 
     (prefix pre string)))) 

इसका मतलब है कि आप कर सकते हैं या तो:

(prefix "foo" 78979) 
=> "foo:78979" 

((prefix "foo") 78979) 
=> "foo:78979" 

यह काफी हास्केल-ish लगता है और partial आंशिक कार्यों बनाने की ज़रूरत नहीं बचा जाता है।

लेकिन यह लिस्प में अच्छा कोडन शैली/एपीआई डिजाइन माना जाता है?

Answer 1

भाषाओं जहां कार्यों डिफ़ॉल्ट रूप से curried कर रहे हैं, कार्यप्रणाली कॉल भी curried कर रहे हैं। जब कोई (f a b c) लिखता है, तो भाषा इसे (((f a) b) c) के रूप में व्याख्या करती है। क्लोजर में यह मामला नहीं है।

मुझे विश्वास है कि ऐसा माहौल कॉल डिफ़ॉल्ट रूप से curried नहीं कर रहे हैं में curried कार्यों बनाने एक वैचारिक बेमेल बनाता है - (। मैं अपने कोड के मानव पाठकों मतलब) इस संरचना शायद पाठकों में भ्रम की स्थिति पैदा होगी

अपने कार्य हैं 2 से अधिक तर्क हैं, परिभाषा बदसूरत हो जाती है। मान लीजिए कि एक समारोह में 4 तर्क हैं। करीनी कॉल को पूरी तरह से अनुकरण करने के लिए, आपको ((f a b) c d) जैसे मामलों को संभालने की आवश्यकता है जब कोई व्यक्ति पहले 2 तर्क और फिर शेष दो पास करता है। इस मामले में दो-तर्क फ़ंक्शन के अधिभारित संस्करण को एक अधिभारित फ़ंक्शन वापस करने की आवश्यकता होती है जो इस पर निर्भर करता है कि यह 1 या 2 तर्क प्राप्त करता है या नहीं। मुझे लगता है कि मैक्रोज़ के साथ स्वचालित करना संभव है, लेकिन फिर भी।

इसके अलावा, आप डिफ़ॉल्ट तर्कों और & rest निर्माण को परिभाषित करने की संभावना मार डालते हैं।

Answer 2

हममम ... व्यक्तिगत रूप से, मैं नहीं बल्कि partial, देखने के बाद से है कि यह स्पष्ट करता है क्या हो रहा है चाहता हूँ।

मैं इसे "अच्छा" या "बुरा" शैली कोडिंग है अगर पता नहीं है, लेकिन मैं कभी नहीं मौजूदा Clojure कोड में से पहले इस शैली को देखा है और मैं कल्पना कर सकते हैं कि एक एपीआई का उपयोग कर लोगों को दोनों (prefix "foo" 78979) और (prefix "foo") की उम्मीद करेंगे उसी तरह की वस्तु वापस करें।

फर्क करने के लिए के बीच दोनों कार्यों को स्पष्ट आप इस के बजाय की तरह कुछ कर सकता है:

(defn prefix [pre string] 
    (str pre ":" string)) 

(defn prefix-fn [pre] 
    (fn [string] 
    (prefix pre string))) 

(prefix "foo" 78979)  ; => "foo:78979" 
((prefix-fn "foo") 78979) ; => "foo:78979" 

Answer 3

एक curried समारोह बनाने के लिए partial का उपयोग स्पष्ट की अवधारणा पर आधारित है बेहतर है (ज्यादातर मामलों में:))। और मैंने पाया है कि इस अवधारणा को गतिशील रूप से टाइप की गई भाषाओं जैसे क्लोजर, पायथन आदि में अधिक लागू/उपयोग किया जा सकता है, गायब प्रकार के हस्ताक्षर/स्थैतिक-टाइपिंग के कारण यह चीजों को स्पष्ट करने के लिए और अधिक समझ में आता है।