क्लोजर - क्रम

क्लोजर लिस्प की एक बोली है, इसलिए यह बिल्कुल आश्चर्यजनक नहीं है कि सूची भाषा में महत्वपूर्ण भूमिका निभाती है। सही है, पारंपरिक बोलियों (सीएल या स्कीम) के विपरीत, क्लासिक डबल-स्लॉट सूचियों के बजाय, क्लोजर सीक्वेंस अमूर्त - "तार्किक सूची" का उपयोग करता है। वास्तव में, यह एक इंटरफ़ेस है जो अपरिवर्तनीय, आलसी और संभवतः अनंत दृश्यों के साथ काम करने के तरीके प्रदान करता है। यह लेख इन संस्थाओं की आंतरिक संरचना का वर्णन करता है।

क्रमों का सार

शुरुआत करते हैं जावा इंटरफेस से। क्लोजर में सभी संरचनाएं लागू होती हैं clojure.lang.Seqable :

public interface Seqable { ISeq seq(); } 

बदले में, clojure.lang.ISeq को इस प्रकार परिभाषित किया गया है:

 public interface ISeq extends IPersistentCollection { Object first(); ISeq next(); ISeq more(); ISeq cons(Object o); } 

यहां आप क्रमशः इटेकेबल , इस्तेक के साथ एक सादृश्य आकर्षित कर सकते हैं - इटरेटर का एक प्रकार का एनालॉग। उनका मुख्य अंतर यह है कि ISeq ऑब्जेक्ट अपरिवर्तनीय हैं: इसके तरीके ऑब्जेक्ट की आंतरिक स्थिति को बदलने के बजाय एक नया उदाहरण (शायद एक अलग प्रकार) भी लौटाते हैं। क्लोजर में सभी अनुक्रम भी एक ही समय में संग्रह हैं - वे विरासत में मिले इंटरफ़ेस को लागू करते हैं clojure.lang.IPersistentCollection , और इसके माध्यम से Seqable :

 public interface IPersistentCollection extends Seqable { int count(); IPersistentCollection cons(Object o); IPersistentCollection empty(); boolean equiv(Object o); } 

यहां हम गणना करते हैं - तत्वों की संख्या की गिनती। अनुक्रमों के लिए, इसकी जटिलता स्पष्ट रूप से O (n) है। खाली विधि उसी प्रकार का एक खाली संग्रह लौटाती है। दृश्यों के लिए, रिटर्न () । खैर, बुरा तरीका एक नया तत्व जोड़ता है।

ISeq ऑब्जेक्ट्स प्राप्त करने के लिए, भाषा seq फ़ंक्शन प्रदान करती है। यदि संग्रह खाली है, तो शून्य वापस कर दिया जाता है, अगर हमारे पास Seqable ऑब्जेक्ट है, तो उस पर seq () विधि को कॉल किया जाता है, अन्यथा एक विशेष आवरण (एडेप्टर) बनाया जाता है। रैपर्स को सरणियों, पुनरावृत्तियों, जावा संग्रह ( मानचित्र सहित) और चारस्पेंसेंस ऑब्जेक्ट्स (स्ट्रिंग्स) के लिए समर्थन किया जाता है। आप इस सूची में अपना प्रकार नहीं जोड़ सकते हैं - यह जावा कोड में "सिलना" है (यहां तक ​​कि प्रोटोकॉल भी मदद नहीं करेगा)। बेशक, आपको एरेज़ (या जावा संग्रह) को बदलना नहीं चाहिए, अगर उनके लिए एक सीक्वेंस बनाया जाए। तो, ConcurrentModificationException को केवल ऊपर फेंक दिया जाता है।

क्लोजर में सिक्वेंस के साथ काम करने के लिए केवल तीन बुनियादी कार्य हैं:

• पहले - अनुक्रम या शून्य का पहला तत्व लें यदि यह खाली है;
• बाकी - "पूंछ" प्राप्त करें, अर्थात्। पहले तत्व के बिना एक अनुक्रम;
• विपक्ष - एक नया अपरिवर्तनीय विपक्ष सेल बनाएं।

विपक्ष के बजाय, संयोजन फ़ंक्शन का उपयोग आमतौर पर नए तत्वों को जोड़ने के लिए किया जाता है। दोनों के बीच का अंतर यह है कि पहले हमेशा एक बस कनेक्ट की गई सूची में एक नया सेल बनाता है, लेकिन दूसरे का परिणाम प्रत्येक विशेष प्रकार के संग्रह के लिए विशिष्ट है - आइटम को सबसे उपयुक्त स्थान पर जोड़ा जाता है। आम कोशिकाओं के लिए यह सूची की शुरुआत है, वैक्टर के लिए यह अंत है, सेट के लिए आदेश बिल्कुल भी परिभाषित नहीं है। यह ध्यान रखना महत्वपूर्ण है कि अगर हमने संग्रह में seq लागू किया है, तो हम इसके प्रकार के बारे में जानकारी खो देते हैं:

 (conj [1 2 3] 4) ;=> [1 2 3 4] (conj (seq [1 2 3]) 4) ;=> '(4 1 2 3) 

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

सभी मानक फ़ंक्शन स्वचालित रूप से seq कहते हैं । उदाहरण के लिए, यदि हम लिखते हैं (cons 1 [2 3]) , तो बनाया गया cons-cell वास्तव में वेक्टर [1 2] को ही नहीं , बल्कि परिणाम (seq [1 2]) को संदर्भित करेगा। अन्य कार्यों (मानचित्र, फिल्टर, आदि) के काम के दौरान एक ही चाल का प्रदर्शन किया जाता है - ये सभी अनुक्रम के साथ काम करते हैं, हालांकि वे संग्रह को मापदंडों के रूप में स्वीकार करते हैं।

वास्तव में, केवल सूचियाँ और विपक्ष कोशिकाएँ सीधे ही इस्क को लागू करती हैं :

 (seq? '(1 2)) ;=> true (seq? ()) ;=> true (seq? (cons 1 nil)) ;=> true (seq? (cons 1 [2 3])) ;=> true (seq? [1 2]) ;=> false (seq? {:a :b}) ;=> false (seq? #{1 2}) ;=> false (seq? nil) ;=> false 

इसलिए, सूची में पुनरावृत्तियों के दौरान, कोई भी अस्थायी ऑब्जेक्ट नहीं बनाया जाता है। लेकिन जब हम वेक्टर के ऊपर जाते हैं, तो प्रत्येक तत्व के लिए एक अस्थायी ISeq उदाहरण बनाया जाता है। वास्तव में, संस्करण 1.1 से चीजें थोड़ी अलग हैं, लेकिन उस पर अधिक।

वहाँ भी एक "कोई नहीं जानता" इंटरफ़ेस clojure.lang.IndexedSeq , सरणियों और तारों के लिए अनुक्रम इसे लागू करते हैं। यह वर्तमान तत्व की संख्या (यानी जहां मूल संग्रह में सिर है ) प्राप्त करने के लिए सूचकांक () विधि को परिभाषित करता है।

 (.index (rest (to-array [1 2 3 4]))) ;=> 1 (.index (rest (rest (to-array [1 2 3 4]))) ;=> 2 

व्यवहार में, इस इंटरफ़ेस का उपयोग कहीं भी नहीं किया गया है (अनडिम्डर्ड फीचर)। हालाँकि, आवेदन के साथ आना वास्तव में कठिन है। वैसे, clojure.lang.APersistenVector $ Seq ऑब्जेक्ट भी इसे लागू करते हैं। लेकिन यहाँ परेशानी यह है कि अब वैक्टर के लिए seq लौंग के उदाहरण देता है। lang.PersistentVector $ ChunkedSeq , जिसकी अब इतनी संदिग्ध क्षमता नहीं है।

आलसी क्रम

क्लोजर में दृश्यों की एक महत्वपूर्ण विशेषता उनका संभावित आलस्य है। इसका मतलब है कि वर्तमान समय में, पूरे अनुक्रम का निर्माण नहीं किया गया है, और इसकी "पूंछ" अभी तक नहीं बनाई गई है। क्लोजर में, यह अक्सर I / O स्ट्रीमिंग के लिए उपयोग किया जाता है।

आलस्य का एहसास बहुत ही सरलता से होता है। वहाँ एक वर्ग है clojure.lang.LazySeq (जो, ज़ाहिर है, ISeq को लागू करता है )। इस वर्ग की वस्तुओं में एक फ़ंक्शन ( IFn उदाहरण) का संदर्भ होता है, जिसे, जब कहा जाता है, तो एक नया अनुक्रम स्वयं लौटना चाहिए (सबसे अधिक संभावना है कि आलसी भी, हालांकि आवश्यक नहीं)। LazySeq विधियों में कोई भी कॉल जनरेटिंग फ़ंक्शन के लिए एक सिंक्रनाइज़ कॉल करता है, इसका परिणाम सहेजा जाता है, और फ़ंक्शन का लिंक स्वयं रीसेट हो जाता है (कचरा कलेक्टर को इसे संसाधित करने की अनुमति देने के लिए)। जाहिर है, पिछले सभी की गणना के बिना एक आलसी अनुक्रम का एक तत्व प्राप्त करने का कोई तरीका नहीं है। यदि आपको केवल इस व्यवहार की आवश्यकता है, तो आप देरी मैक्रो का उपयोग कर सकते हैं।

 (nth (map #(print % "") (iterate inc 0)) 5) ;=> 1 2 3 4 5 @(nth (map #(delay (print % "")) (iterate inc 0)) 5) ;=> 5 

अपने कोड में आलसी क्रम उत्पन्न करना हास्यास्पद सरल है। यह कोड को डालने के लिए पर्याप्त है जो आलसी-सीक मैक्रो के अंदर विपक्ष को कॉल करता है। लेकिन, वास्तव में, किसी को भी यह सबसे अधिक बार नहीं करना पड़ता है - अधिकांश मानक कार्य (बहुत कुछ अपवादों के साथ) सिर्फ आलसी संग्रह लौटाते हैं, हमारे लिए सभी "गंदे" काम करते हैं। यहाँ सत्य और मामूली बारीकियाँ हैं।

तो, इसकी गणना में, आलसी अनुक्रम वास्तव में एक सरल, बस जुड़ी हुई सूची में बदल जाता है, और यदि आप पहले तत्व के लिए एक लिंक संग्रहीत करते हैं, तो स्मृति समस्याएं हो सकती हैं। क्लासिक उदाहरण:

 (def all-odds (filter odd? (range))) (println (nth all-odds 20000000)) 

यहां हम 20,000,000 वें विषम संख्या का पता लगाने की कोशिश कर रहे हैं। और यह इसे ढूँढता है, लेकिन यह सिर्फ मध्यवर्ती इस्किम के उदाहरण हैं जो स्मृति में बने हुए हैं। सही निर्णय:

 (defn make-all-odds [] (filter odd? (range))) (println (nth (make-all-odds) 2000000)) 

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

 (first '(1 2 3)) ;=> 1 (rest '(1 2 3)) ;=> '(2 3) (rest '(1)) ;=> () (rest ()) ;=> () (next '(1)) ;=> nil (next ()) ;=> nil 

यह अधिक आलस्य के लिए किया जाता है। वास्तव में, यदि अनुक्रम आलसी है, तो सामान्य मामले में हम नहीं जानते कि इसमें अधिक तत्व हैं या नहीं। इस तथ्य को अगले के साथ सत्यापित करने के लिए , हमें कम से कम पहले 2 तत्वों की गणना करने की आवश्यकता है: हम पहले को छोड़ देंगे, और दूसरे की उपस्थिति से हम समझेंगे कि क्या शून्य वापस किया जाना चाहिए। खैर, 2 तत्वों की गणना - यह स्पष्ट रूप से वह नहीं है जो हमें आमतौर पर चाहिए।

यदि आलसी व्यवहार की आवश्यकता नहीं है, तो पूरे अनुक्रम को डोरुन और डॉल फ़ंक्शन का उपयोग करके पूरी तरह से गणना की जा सकती है । पहला मूल अनुक्रम लौटाता है, दूसरा - शून्य।

 (dorun (map #(println % "") (range 5)));=> 1 2 3 4 5 

ब्लॉक अनुक्रम

आलसी संग्रह एक बहुत शक्तिशाली उपकरण है, लेकिन व्यवहार में हम अक्सर पूरे संग्रह को संसाधित करते हैं, और आलसी-सेक मूर्त उपरि लाता है। इसलिए, संस्करण 1.1 में, एक महत्वपूर्ण अनुकूलन किया गया था - chunked seqences। नीचे की रेखा सरल है - जब आलसी दृश्यों को संसाधित करते हैं, तो हम व्यक्तिगत तत्वों के साथ नहीं, बल्कि उनके समूहों के साथ काम कर रहे हैं। उसी समय, "विकास" तत्वों की एक संख्या को लालच से गणना की जाती है।

लगता है कि यह कोड आउटपुट क्या है?

 (first (map #(print % "") (range 100))) 

तो, क्लोजर एक विशेष इंटरफ़ेस clojure.lang.IChunkedSeq को परिभाषित करता है। इस तंत्र के जावा भाग का वर्णन करने में कोई मतलब नहीं है, इसलिए मैं इसे छोड़ दूंगा। वैक्टर के लिए केवल अनुक्रम इंटरफ़ेस को लागू करते हैं। ठीक है, और, जैसा कि हमने देखा, रेंज फ़ंक्शन का परिणाम है।

इस तरह के दृश्यों के प्रसंस्करण के लिए एल्गोरिथ्म:

• जाँच करें कि क्या स्रोत IChunkedSeq है ( chunked-seq function ? );
• यदि नहीं, तो हम एल्गोरिथ्म (बिटवाइज़ प्रोसेसिंग) के सामान्य संस्करण का प्रदर्शन करते हैं;
• यदि ऐसा है, तो हम अनुक्रम से पहला ब्लॉक लेते हैं ( chunk-first function);
• इसके आकार ( चंक-आकार फ़ंक्शन) को देखें;
• एक नया ब्लॉक बनाएं, हम उत्पन्न तत्वों को वहां रखेंगे ( चंक-बफर फ़ंक्शन);
• वास्तव में उपयोगी काम कर रहा है, ब्लॉक में तत्वों को जोड़ना ( चंक-एपेंड फ़ंक्शन);
• ChunkedCons (फ़ंक्शन chunk-cons ) में हमारे नए ब्लॉक को लपेटें।

एक उदाहरण के लिए हम अपना कार्यान्वयन # (विषम विषम?%) लिखेंगे। एक सरल विकल्प:

 (defn filter-odd-1 [a] (lazy-seq (when-let [s (seq a)] (let [f (first s) r (rest s)] (if (odd? f) (cons f (filter-odd-1 r)) (filter-odd-1 r)))))) 

उन्नत विकल्प (ब्लॉक समर्थन के साथ):

 (defn filter-odd-2 [a] (lazy-seq (when-let [s (seq a)] (if (chunked-seq? s) (let [f (chunk-first s) c (count f) b (chunk-buffer c)] (dotimes [ic] (let [x (nth fi)] (when (odd? x) (chunk-append bx)))) (chunk-cons (chunk b) (filter-odd-2 (chunk-rest s)))) (let [f (first s) r (rest s)] (if (odd? f) (cons f (filter-odd-2 r)) (filter-odd-2 r))))))) 

बेशक, थोड़ा अधिक कोड था, और स्पष्ट दोहराव था: हमें दो अलग-अलग कार्यान्वयन बनाने थे। लेकिन ऐसी गति की कीमत है। सौभाग्य से, अधिकांश मानक सुविधाएँ पहले से ही पूरी तरह से विखंडू का समर्थन करती हैं। मैं ध्यान देता हूं कि अनुक्रम में विभिन्न लंबाई के ब्लॉक शामिल हो सकते हैं (ब्लॉक एक साथ चिपकते नहीं हैं, लेकिन कभी-कभी वे कट जाते हैं, जैसा कि ऊपर दिए गए उदाहरण में है), और यहां तक ​​कि सामान्य तत्वों और ब्लॉकों का मिश्रण भी हो सकता है।

क्या होगा यदि हम एक नियमित अनुक्रम को ब्लॉक अनुक्रम में बदलना चाहते हैं? आपको बस vec फ़ंक्शन का उपयोग करके इसे वेक्टर में बदलना होगा। कांसेप्ट पहले से ही थोड़ा अधिक जटिल है:

 (defn seq1 [s] (lazy-seq (when-let [x (seq s)] (cons (first x) (seq1 (rest x)))))) (first (map println (seq1 (range 1000)))) ;=> 1 

यह भी उम्मीद है कि कम फ़ंक्शन ब्लॉक अनुक्रमों का लाभ उठाता है। तो, प्रत्येक ब्लॉक में एक विशेष विधि होती है जो अस्थायी वस्तुओं को बनाए बिना एक जावा चक्र में संकेतन करती है। सामान्य तौर पर, कम में अन्य अनुकूलन भी होते हैं , हर कोई दिलचस्पी clojure.core.protocols देख सकता है ।

एक निष्कर्ष के बजाय

क्लोजर अनुक्रम शक्तिशाली और सुविधाजनक हैं। उनकी निस्संदेह प्लस यह है कि अक्सर आप इस तरह के "trifles" के बारे में सोच भी नहीं सकते हैं जैसे कि आलस्य या ब्लॉक प्रसंस्करण - क्लोजर हमारे लिए यह करने की कोशिश करता है।