जो मैं लागू करने के बारे में समझता हूं उससे, यह एक सूची को अनपैक करता है और तत्वों को फ़ंक्शन के लिए तर्कों में बदल देता है।क्लोजर में क्यों नहीं (लागू या [सही झूठा]) काम करता है?
मुझे लगता है कि (लागू + [1 2 3]) अपेक्षित काम करता है, यानी: यह बराबर है (+ 1 2 3)।
फिर क्यों (लागू या [सही झूठा]) अवैध है? क्या यह बराबर नहीं है (या सच झूठा)?
क्योंकि or एक मैक्रो है, सामान्य कार्य नहीं। आप (some identity [true false]) के साथ एक ही प्रभाव प्राप्त कर सकते हैं।
या के विकल्प के रूप में आप (कुछ अनुमानित कॉल का उपयोग कर सकते हैं) का उपयोग कर सकते हैं।
clojure.core/कुछ ([pred coll])
रिटर्न की (pred एक्स) पहले तार्किक सही मूल्य coll में किसी भी एक्स के लिए, बाकी नहीं के बराबर। फ्रेड यदि:: फ्रेड, नहीं तो नहीं के बराबर अनुक्रम में है: (कुछ # {: फ्रेड} coll)
आप कोशिश कर सकते हैं एक आम मुहावरा एक सेट रूप महीनो, उदाहरण के लिए इस वापसी करेंगे उपयोग करने के लिए है कुछ सच के साथ? और झूठा? विधेय,
user=> (some true? [true false false])
true
user=> (not (some true? [true false false]))
false
user=> (some false? [true false false])
true
user=> (not (some false? [true false false]))
false
झूठी से सावधान रहें ?! (झूठी? शून्य) झूठी झूठ बोलने के बावजूद झूठी वापसी करता है। (बुलियन नील) हालांकि झूठी वापसी करता है। – cgrand
या एक मैक्रो है, जिसे आप मूल्य के रूप में उपयोग नहीं कर सकते है।
एक गुमनाम समारोह बनाएँ, eval के माध्यम से क्रम पर या का विस्तार:
(apply #(eval (list* 'or %&)) [true false])
चूंकि आप मैक्रोज़ के बिना अधिक स्वाभाविक रूप से एक ही परिणाम प्राप्त कर सकते हैं ('करके (# (या% 1% 2) को कम करें ...) '), यह उन मामलों में से एक है जहां' eval' का उपयोग करना एक बुरा विचार है। मामले में मामला: आपका फॉर्म ऐसा नहीं करता जो 'या' करता है। उदाहरण के लिए, वेक्टर '[' (या) झूठी] पर इसका उपयोग करने का प्रयास करें। –
महत्वपूर्ण बातों में से एक है, हालांकि नोट करने के लिए मूल्यांकन मॉडल है। or शॉर्ट सर्किट, इसलिए: (or true :some random expression that never gets evaluated:) कभी अंतिम का मूल्यांकन नहीं करता है। or पारंपरिक रूप से एक नियंत्रण संरचना के रूप में 'तार्किक या' के रूप में उपयोग किया जाता है।
(f x y z), x, y, और z के पारंपरिक मॉडल में मूल्यांकन किया जाता है, और एफ उन्हें लागू किया जाता है।
(apply f vec) के उपयोग में वेक्टर की सामग्री मूल्यांकन नहीं है, वे इस प्रकार के रूप में लिया जाता है। यह प्रतीकों के वेक्टर के साथ सबसे स्पष्ट रूप से दिखाई देता है, वे इस संदर्भ में उनके बाइंडिंग में मूल्यांकन नहीं करते हैं। हालांकि, यह इस तथ्य से गुमराह है कि वेक्टर सृजन के लिए क्लोजर का मॉडल कुछ अलग-अलग है, तो अन्य लिस्प्स, [a b c d] एक वेक्टर उत्पन्न करता है जिसमें प्रतीकों का मूल्यांकन a, b, c, और d है। अधिकांश लिस्पस की तुलना में, जिसमें #(a b c d) प्रतीकों का मूल्यांकन नहीं करता है, और (vector 'a 'b 'c 'd) (या वास्तव में (apply vector '(a b c d))) का मूल्यांकन करने के समान है।
तो यदि विशेष वाक्य रचनात्मक रूपों को लागू करना संभव था, तो इसके परिणामस्वरूप एक अपारदर्शी अर्थशास्त्र होगा। or सबसे पहले अपने पहले तर्क का मूल्यांकन करता है, यदि सही है, तो यह बंद हो जाता है और उसे वापस लौटाता है, अन्यथा यह दूसरे पर जाता है और आखिरी तक दोहराता है। आवेदन के मामले में, तर्क पहले से ही सभी मूल्यांकन किए गए हैं, क्या इसे फिर किसी दूसरी बार मूल्यांकन करना चाहिए? सबसे अधिक संभावना रास्ते में एक रनटाइम त्रुटि के परिणामस्वरूप?
कार्यान्वयन परिप्रेक्ष्य से, यह बहुत ही प्रदर्शनशील होगा यदि वाक्यविन्यास 'ऑब्जेक्ट' भी था और उसे अधिक जटिल मूल्यांकन मॉडल की आवश्यकता होगी। इसलिए वे रनटाइम पर हल नहीं होते हैं, बल्कि संकलन समय पर कंपाइलर प्राइमेटिव्स को फिर से लिखते हैं।
लेकिन, इसी कारण से, जब or तार्किक एक नियंत्रण संरचना के रूप में के बजाय प्रयोग किया जाता है के लिए, मैं अपने आप को यह काम कार्यों or/f, and/f, if/f, वगैरह उपलब्ध जो सच प्रक्रियाएं हैं और उनके सभी तर्क का मूल्यांकन करने लगता है और इस प्रकार लागू किया जा सकता है।
आह। धन्यवाद! क्या आप किसी भी विकल्प के बारे में सोच सकते हैं? – TriArc
'(# (या% 1% 2) को कम करें [सच झूठा ...])' –
मैंने सोचा था कि 'कुछ' 'comp (comp पहले फ़िल्टर) था जब तक चूसर ने मुझे और अधिक जटिल वास्तविकता दिखाई नहीं दी। कोशिश करें '(कुछ: एक [{: एक झूठी} {: एक nil} {: एक सत्य}])', फिर 'कुछ 'को' (comp पहले फ़िल्टर) 'से बदलें। –