     (for [i (range iters)]
       (time-ms amt-per-iter afn))))
 
-(defn compare-benchmark [iters amt-per-iter afn-map]
+(defn compare-benchmark [amt-per-iter afn-map]
   (let [results (transform [ALL LAST]
                   (fn [afn]
-                    (average-time-ms iters amt-per-iter afn))
+                    (average-time-ms 8 amt-per-iter afn))
                   afn-map)
         [[_ best-time] & _ :as sorted] (sort-by last results)
         ]


(let [data {:a {:b {:c 1}}}
      p (comp-paths :a :b :c)]
  (run-benchmark "get value in nested map" 6 10000000
    (get-in data [:a :b :c])
    (select [:a :b :c] data)
    (compiled-select p data)

          (my-update m3 :c afn))))))

(let [data {:a {:b {:c 1}}}]
  (run-benchmark "update value in nested map" 1000000
    (update-in data [:a :b :c] inc)
    (transform [:a :b :c] inc data)
    (manual-transform data inc)
    ))

(let [data [1 2 3 4 5]]
  (run-benchmark "map a function over a vector" 1000000
    (vec (map inc data))
    (mapv inc data)
    (transform ALL inc data)
