transducers.cljc

 (ns transducers)

;;;;; simplified traditional impls
 
 (defn mymap [f coll]
   (reduce 
     (fn [acc n]
       (conj acc (f n)))
     []
     coll))


(defn myfilter [f coll]
  (reduce
    (fn [acc n]
      (if (f n)
        (conj acc n)
        acc))
    []
    coll))

(mymap inc [1 2 3 4 5])
(myfilter odd? [1 2 3 4 5])
 
;;;;;;;;;;;;;;;; transducer versions
 
 (defn mapx [f]
   (fn [process]
     (completing (fn [acc n]
                   (process acc (f n))))))

(defn filterx [f]
  (fn [process]
    (completing (fn [acc n]
                  (if (f n)
                    (process acc n)
                    acc)))))

 
(reduce
  ((comp
     (mapx inc)
     (filterx odd?))
   conj)
  #{} [2 3 4 5 6])

 
;needed to add 'completing' to xf so last step of transduce works
; (conj) returns [], the output coll
 (transduce
   (comp
     (mapx inc)
      (filterx odd?))
   conj [2 3 4 5 6])
 
 ; provide the output coll. clojure uses conj under the hood
 (into #{} (comp
             (mapx inc)
             (filterx odd?)) [2 3 4 5 6])