(require '[clojure.string :as str]
         '[clojure.template :refer [do-template]]
         '[criterium.core :as crit]
         '[net.cgrand.xforms :as x])

(defn bench [map-sizes]
   (let [os-details (crit/os-details)
         runtime-details (crit/runtime-details)]
      (println "```text")
      (println "Clojure version:" (:clojure-version-string runtime-details))
      (apply println ((juxt :vm-name :vm-version) runtime-details))
      (apply println
             (-> ((juxt :arch :name :version :available-processors) os-details)
                 (conj "cpu(s)")))
      (println "```")

      (println)

      (println "| scenario \\ map size |" (str/join " | " map-sizes) "|")
      (apply println "| --- |" (repeat (count map-sizes) "--- |"))

      (do-template
         [testcase form]
         (do
            (print "|" testcase)
            (doseq [map-size map-sizes]
               (let [m (zipmap (range map-size) (range))
                     results (crit/quick-benchmark form nil)
                     mean-str (with-out-str (crit/report-point-estimate "Mean" (:mean results)))
                     dev-str (with-out-str (crit/report-point-estimate-sqrt "Std dev" (:variance results)))]
                  (print " |" (str/trim mean-str) "<br/>" (str/trim dev-str))))
            (println " |"))

         "into with lazy sequence"
         (into {} (for [[k v] m] [k (inc v)]))

         "into with mapping transducer"
         (into {} (map (fn [[k v]] [k (inc v)])) m)

         "into with x/for (pairs are still allocated)"
         (into {} (x/for [[k v] _] [k (inc v)]) m)

         "x/into with x/for (no pairs are allocated)"
         (x/into {} (x/for [[k v] _] [k (inc v)]) m))))

;; run benchmark
(bench [10 100 200 400 1000 100000])