क्लोजर: कॉल करने के लिए बेवकूफ तरीका शामिल है? आलसी अनुक्रम पर

Question

क्या यह निर्धारित करने का एक बेवकूफ तरीका है कि LazySeq में कोई तत्व है या नहीं? Clojure 1.5 के रूप में बुला contains? एक IllegalArgumentException फेंकता है:

IllegalArgumentException contains? not supported on type: clojure.lang.LazySeq  
clojure.lang.RT.contains (RT.java:724) 

1,5 से पहले, जहाँ तक मुझे पता है, यह हमेशा झूठे लौट आए।

मुझे पता है कि LazySeq पर contains? पर कॉल करना कभी वापस नहीं हो सकता है क्योंकि यह अनंत हो सकता है। लेकिन अगर मुझे पता है कि यह नहीं है और परवाह नहीं है तो इसका उत्सुकता से मूल्यांकन किया जाता है?

क्या मैं के साथ आया है:

(defn lazy-contains? [col key] 
    (not (empty? (filter #(= key %) col)))) 

लेकिन यह बहुत सही नहीं लगता है। क्या कोई बेहतर तरीका है?

Answer 1

सबसे पहले, आलसी seqs सदस्यता की जांच के लिए कुशल नहीं हैं। एक आलसी seq के बजाय एक सेट का उपयोग करने पर विचार करें।

यदि कोई सेट अव्यवहारिक है, तो आपका समाधान खराब नहीं है। कुछ संभावित सुधार:

1. "खाली नहीं" थोड़ा अजीब है। बस सीक का उपयोग करना एक शून्य-या-सत्य मूल्य प्राप्त करने के लिए पर्याप्त है जो आपके उपयोगकर्ता किसी भी रूप में उपयोग कर सकते हैं। यदि आप सच या गलत चाहते हैं तो आप इसे बुलियन में लपेट सकते हैं।

2. चूंकि आप केवल पहले मैच की परवाह करते हैं, आप फ़िल्टर और सीक के बजाय कुछ का उपयोग कर सकते हैं।

3. समानता भविष्यवाणी लिखने का एक सुविधाजनक तरीका एक शाब्दिक सेट के साथ है, जैसे कि # {कुंजी}, हालांकि यदि कुंजी शून्य है तो यह हमेशा शून्य हो जाएगी कि शून्य हमें नहीं मिला है।

सभी एक साथ आप देता है:

(defn lazy-contains? [col key] 
    (some #{key} col)) 

Answer 2

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

(defn lazy-contains? [coll key] 
    (boolean (some #(= % key) coll))) 

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