मैं एक आलसी-सेक वेक्टर

Question

बनाने रनिंग इस अपेक्षा के अनुरूप काम करता है कैसे कर सकते हैं:

(defn long-seq-vec [n] 
    (lazy-seq (into 
      (vector (list n {:somekey (* n 2)})) 
      (long-seq-vec (+ n 1))))) 
(take 3 (long-seq-vec 3)) 

यह मैं एक ढेर देता है:

(defn long-seq [n] 
    (lazy-seq (cons 
      (list n {:somekey (* n 2)}) 
      (long-seq (+ n 1))))) 
(take 3 (long-seq 3)) 
; => ((3 {:somekey 6}) (4 {:somekey 8}) (5 {:somekey 10})) 

हालांकि मैं एक वेक्टर के साथ एक ही बात करना चाहते हैं अतिप्रवाह। क्यूं कर?

Answer 1

मुख्य कारण यह है कि वैक्टर आलसी नहीं हैं - तो into कॉल लालच से एक ढेर अतिप्रवाह में long-seq-vec और परिणाम द्वारा उत्पादित पुनरावर्ती दृश्यों खपत करता है। इस के एक सारांश के रूप में, एक अनंत वेक्टर बनाना संभव नहीं है (सामान्य रूप से, यदि आप आलसी या चक्रीय हैं तो आप केवल एक अनंत डेटा संरचना बना सकते हैं)।

यह पहले उदाहरण में काम करता है क्योंकि cons आलसी अनुक्रम के सामने परवाह करते समय आलसी व्यवहार करने में काफी खुश है, इसलिए अनुक्रम अनंत हो सकता है।

मान लिया जाये कि आप वास्तव में चाहते हैं वैक्टर की एक अनंत अनुक्रम मैं की तरह कुछ सुझाव देंगे:

(defn long-seq-vec [n] 
    (for [x (iterate inc n)] 
    (vector x {:somekey (* x 2)}))) 

मैं:

(defn long-seq-vec [n] 
    (lazy-seq (cons 
       (vector n {:somekey (* n 2)}) 
       (long-seq-vec (+ n 1))))) 

(take 3 (long-seq-vec 3)) 

=> ([3 {:somekey 6}] [4 {:somekey 8}] [5 {:somekey 10}]) 

या एक विकल्प के रूप में, आप for जो अपने आप में आलसी है उपयोग कर सकते हैं इसे पसंद करें क्योंकि यह lazy-seq/cons बॉयलरप्लेट से बचाता है, रिकर्सन से बचाता है और यह आपके व्यक्तित्व को व्यक्त करने में थोड़ा और स्पष्ट है ... यदि आप चाहें तो यह थोड़ा और अधिक "घोषणात्मक" है। आप इसी तरह से map का भी उपयोग कर सकते हैं।