clojure
ट्रांसड्यूसर

परिचय

टिप्पणियों

(take 0 (sequence (map #(do (prn '-> %) %)) (range 5)))
;; -> 0
;; => ()

(take 0 (sequence (comp (map #(do (prn '-> %) %)) (remove number?)) (range 5)))
;; -> 0
;; -> 1
;; -> 2
;; -> 3
;; -> 4
;; => ()

(take 0 (map #(do (prn '-> %) %) (range 5)))
;; => ()

एक वेक्टर पर लागू छोटे ट्रांसड्यूसर

(let [xf (comp
           (map inc)
           (filter even?))]
  (transduce xf + [1 2 3 4 5 6 7 8 9 10]))
;; => 30

यह उदाहरण स्थानीय xf को निर्दिष्ट ट्रांसड्यूसर बनाता है और इसे कुछ डेटा पर लागू करने के लिए transduce का उपयोग करता है। ट्रांसड्यूसर प्रत्येक के इनपुट में से एक को जोड़ता है और केवल सम संख्या देता है।

transduce reduce जैसा है, और प्रदान किए गए + फ़ंक्शन का उपयोग करके इनपुट संग्रह को एक एकल मान तक ढह जाता है।

यह थ्रेड-अंतिम मैक्रो की तरह पढ़ता है, लेकिन गणना से इनपुट डेटा को अलग करता है।

(->> [1 2 3 4 5 6 7 8 9 10]
     (map inc)
     (filter even?)
     (reduce +))
;; => 30

ट्रांसड्यूसर लागू करना

(def xf (filter keyword?))

एक संग्रह पर लागू होता है, एक अनुक्रम लौटाता है:

(sequence xf [:a 1 2 :b :c]) ;; => (:a :b :c)

किसी अन्य फ़ंक्शन के साथ परिणामी संग्रह को कम करने, एक संग्रह पर लागू करें:

(transduce xf str [:a 1 2 :b :c]) ;; => ":a:b:c"

एक संग्रह पर लागू करें, और परिणाम को दूसरे संग्रह में conj करें:

(into [] xf [:a 1 2 :b :c]) ;; => [:a :b :c]

संदेशों को फ़िल्टर करने के लिए एक ट्रांसड्यूसर का उपयोग करने वाला एक मुख्य async चैनल बनाएँ:

(require '[clojure.core.async :refer [chan >!! <!! poll!]])
(doseq [e [:a 1 2 :b :c]] (>!! ch e))
(<!! ch) ;; => :a
(<!! ch) ;; => :b
(<!! ch) ;; => :c
(poll! ch) ;;=> nil

ट्रांसड्यूसर बनाना / उपयोग करना

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

(map inc) एक ट्रांसड्यूसर लौटाता है और ऐसा करता है (filter odd?)

लाभ: कार्यों को COMP द्वारा एकल फ़ंक्शन में बनाया जा सकता है, जिसका अर्थ है कि संग्रह को केवल एक बार ट्रेस करना। कुछ स्थितियों में बचत 50% से अधिक समय तक चलती है।

परिभाषा:

(def composed-fn (comp (map inc) (filter odd?)))

उपयोग:

;; So instead of doing this:
(->> [1 8 3 10 5]
     (map inc)
    (filter odd?))
;; Output [9 11]

;; We do this: 
(into [] composed-fn [1 8 3 10 5])
;; Output: [9 11]