Transmuter benchmarking

benchmarks.txt

(def v (vec (concat (range 1000) (range 1000))))
(into [] …)

                       seq / transducer / transmuter
(distinct v):        969µs /      489µs /      331µs
(interpose nil v):   458µs /       43µs /      102µs
(take 1000 v):       114µs /       34µs /       28µs
(drop 1000 v):        41µs /       51µs /       43µs
(map inc v):          68µs /       43µs /       56µs
(filter even? v):     51µs /       29µs /       45µs
(take-last 50 v):     38µs /            /       78µs
(drop-last 50 v):    263µs /            /      121µs
(partition 3 1 v):   1.6ms /            /      705µs
(partition 3 2 v):   844µs /            /      438µs

-------------------------

(def f (constantly nil))
(into [] …)

                                    seq / transmuter / seq fallback
(take 2000 (repeat 1)):           304µs /       43µs /        315µs
(repeat 2000 1)):                 320µs /       43µs /        187µs

(take 2000 (repeatedly f)):       304µs /       45µs /        299µs
(repeatedly 2000 f):              302µs /       40µs /        161µs

(take 2000 (iterate inc 0)):      301µs /       53µs /        335µs

(take 2000 (cycle [1 2 3 4 5])):  296µs /       93µs /        358µs

-------------------------

(def v (vec (range 100000)))

(->> v
  (map #(+ % 10))
  (map #(* % 2))
  (filter #(zero? (rem % 5)))
  (filter #(zero? (rem % 2))))

(comp
  (map #(+ % 10))
  (map #(* % 2))
  (filter #(zero? (rem % 5)))
  (filter #(zero? (rem % 2))))

[(t/map #(+ % 10))
 (t/map #(* % 2))
 (t/filter #(zero? (rem % 5)))
 (t/filter #(zero? (rem % 2)))]

          seq    / transducer / transmuter
into:     11.7ms /      8.0ms /     10.7ms
sequence: 11.8ms /     10.8ms /     11.6ms