क्लोजर: कम करें, कटौती और अनंत सूचियां

Question

कम करें और कटौती आपको अनुक्रम पर राज्य जमा करने दें। अनुक्रम में प्रत्येक तत्व तक संचित स्थिति को संशोधित करेगा, अनुक्रम का अंत तक पहुंच जाएगा।

असीमित सूची को कम करने या घटाने के प्रभाव क्या हैं?

(def c (cycle [0])) 
(reduce + c) 

यह जल्दी से आउटऑफमेमरी एरर फेंक देगा। वैसे, (reduce + (cycle [0])) एक आउटऑफमेमरी त्रुटि नहीं फेंकता है (कम से कम उस समय के लिए नहीं जब तक मैं इंतजार कर रहा था)। यह कभी वापस नहीं आता है। यकीन नहीं है कि क्यों।

क्या असीमित सूची को कम करने या घटाने के तरीके को समझने का कोई तरीका है जो समझ में आता है? उपर्युक्त उदाहरण में जो समस्या मैं देखता हूं, वह है कि अंततः सूची का मूल्यांकन हिस्सा ढेर को बहने के लिए काफी बड़ा हो जाता है। शायद एक अनंत सूची सही प्रतिमान नहीं है। जनरेटर, आईओ स्ट्रीम, या एक इवेंट स्ट्रीम को कम करने से अधिक समझदारी होगी। मूल्यांकन के मूल्यांकन के बाद मूल्य को नहीं रखा जाना चाहिए और राज्य को संशोधित करने के लिए उपयोग किया जाना चाहिए।

Answer 1

यह कभी वापस नहीं आएगा क्योंकि एक अनुक्रम और एक समारोह लेता है और तक फ़ंक्शन लागू करता है इनपुट अनुक्रम खाली होता है, केवल तभी यह पता चल सकता है कि इसका अंतिम मूल्य है।

वास्तव में अनंत सीक पर कम करना बहुत समझ में नहीं आता है जब तक कि यह अपनी प्रगति को लॉगिंग करने जैसे साइड इफेक्ट का उत्पादन नहीं कर रहा हो।

आपके पहले उदाहरण में आप पहले एक अनंत अनुक्रम को संदर्भित करते हुए एक var बना रहे हैं।

(def c (cycle [0])) 

फिर आप var c की सामग्री को पार कर रहे हैं जिससे कम करने के लिए तत्वों को पढ़ना शुरू हो जाता है।

(reduce + c) 

इन तत्वों को कचरा एकत्र नहीं किया जा सकता क्योंकि वर ग उनमें से पहले, जो बारी में दूसरे और इतने पर के लिए एक संदर्भ रखती है के लिए एक संदर्भ रखती है। अंततः यह वहाँ है ढेर में अंतरिक्ष और फिर यह OOM के रूप में कई पढ़ता है।

अपने दूसरे उदाहरण में ढेर उड़ाने से रोकने के लिए आप पहले से उपयोग किए गए डेटा का संदर्भ नहीं रख रहे हैं, इसलिए चक्र द्वारा लौटाए गए सीक पर आइटम जीसीडी जितनी जल्दी हो सके उतने ही होते हैं और संचित परिणाम जारी रहता है बडे बनो। अंततः यह एक लंबी और दुर्घटना (clojure 1.3) अतिप्रवाह होगा या एक BigInteger करने के लिए स्वयं को बढ़ावा देने और सब ढेर (clojure 1,2)

(reduce + (cycle [0])) 

Answer 2

आर्थर की जवाब है, के रूप में यह हो जाता है जहाँ तक अच्छी है, लेकिन यह के आकार के बढ़ने दिखता है जैसे वह reductions के बारे में अपने दूसरे प्रश्न का समाधान नहीं करता। reductions यदि एक सूची केवल एन तत्वों लंबे दी क्या reduceहोगा वापस आ गए के मध्यवर्ती चरणों में से एक आलसी अनुक्रम देता है। तो यह एक अनंत सूची पर reductions कॉल करने के लिए पूरी तरह से समझदार है:

user=> (take 10 (reductions + (range))) 
(0 1 3 6 10 15 21 28 36 45) 

Answer 3

आप एक आईओ धारा की तरह एक सूची से आइटम हो रही रखने के लिए और रन के बीच राज्य रखना चाहते हैं, तो आप का सहारा के बिना doseq (उपयोग नहीं कर सकते डीईएफ़ के)।इसके बजाय एक अच्छा दृष्टिकोण पाश उपयोग करने के लिए/पुनरावृत्ति होना यह आप लेने वाली बहुत ज्यादा ढेर अंतरिक्ष से बचने के लिए अनुमति देगा हो सकता है और आप राज्य रख दूँगी आपके मामले में,:

(loop [c (cycle [0])] 
    (if (evaluate-some-condition (first c)) 
    (do-something-with (first c) (recur (rest c))) 
    nil)) 

बेशक

अपने मामले की तुलना में नहीं है यहां एक शर्त जांचें कि यह सुनिश्चित करने के लिए कि हम अनिश्चित काल तक लूप नहीं करते हैं।

Answer 4

के रूप में अन्य लोगों ने बताया है, यह एक अनंत क्रम पर सीधे को कम चलाने के लिए, के बाद से कम हो मतलब नहीं है गैर आलसी है और पूर्ण अनुक्रम का उपभोग करने की जरूरत है।

स्थिति के इस प्रकार के लिए एक विकल्प के रूप में, यहाँ एक उपयोगी समारोह है कि एक दृश्य में केवल पहले n आइटम को कम कर देता है, उचित दक्षता के लिए पुनरावृत्ति होना का उपयोग कर लागू किया:

(defn counted-reduce 
    ([n f s] 
    (counted-reduce (dec n) f (first s) (rest s))) 
    ([n f initial s] 
    (if (<= n 0) 
     initial 
     (recur (dec n) f (f initial (first s)) (rest s))))) 

(counted-reduce 10000000 + (range)) 
=> 49999995000000