(let [mystery (identity Double/NaN)
      mystery2 (. Double NaN)
      mystery3 Double/NaN]
  [(= mystery mystery) (= mystery2 mystery2) (= mystery3 mystery3)])

[true true true]

(let [foo (partial list 'foo)]
  (reduce (fn [acc args] (apply foo acc args))
    'seed
    '[[arg1 arg2] [arg3 arg4] [arg5 arg6]]))

(foo (foo (foo seed arg1 arg2) arg3 arg4) arg5 arg6)

(do (let [col (for [x (range 100) y (range 1 100)] [x y])]
      (reduce #(map + %1 %2) col))
    nil)

nil

(let [y "\ufeffPersonnelNbr"
      x (clojure.string/replace y #"\p{Cf}|\p{Cc}" "")]
  (= (read-string (pr-str x)) x (read-string (pr-str y)) y))

false

(let [p '{a 100, b 200, c 50} ks (keys p) cvs (reductions + 0 (vals p))] cvs)

(0 100 300 350)

(let [twodvec [[1 2 3] [4 5 6] [7 8 9]]]
  (for [a twodvec b a] (+ b (apply max a))))

(4 5 6 10 11 12 16 17 18)

(let [a (byte-array (map byte [1 2 3 4 5]))]
  (println (into [] a))
  (aset-byte a 1 (byte 42))
  (println (into [] a)))

nil

"[1 2 3 4 5]\n[1 42 3 4 5]\n"

(let [m {:k1 {:a [1]}, :k2 {:a []}, :k3 {:a nil}}]
  (select-keys m (for [[k v] m :when (not-empty (:a v))] k)))

{:k1 {:a [1]}}

(let [a #{1 3 4 5 7} b (conj a 8)] [(b 2) (b 3) (b 5) (b 6)])

[nil 3 5 nil]

(let [m {:a 1, :b 2} ms [m {:a 2, :b 4} {:a 5, :b 9}]] ((frequencies ms) m))

1

(let [slash (char-escape-string \\)
      re-bracket #"\["
      bracket \[
      target "foo[bar"
      replacement (str slash bracket)]
  (print (clojure.string/replace target re-bracket replacement)))

nil

"foo\\[bar"

(let [m {:a 1, :b 2, :c {"foo" "bar"}}]
  (apply merge (for [[k v] m] (if (map? v) v {k v}))))

{:a 1, :b 2, "foo" "bar"}

(defmacro daset
  [a vals]
  `(let [#^doubles b# ~a]
     ~@(for [[idx val] (partition 2 vals)] `(aset b# ~idx ~val))))

#'user/daset

(let [=? (fn [& args] (fn [x] ((zipmap args (repeat true)) x)))]
  (some (=? 1 2 3) (range 0 10 4)))

nil

(reductions (fn [[mx sum] v] (let [update (+ v sum)] [(max update mx) update]))
            [0 0]
            [1 2 -30 8 12])

([0 0] [1 1] [3 3] [3 -27] [3 -19] [3 -7])

(defn wrap-utf8-html
  [handler]
  (fn [request]
    (let [response (handler request)
          content-type (get-in response [:headers "Content-Type"])]
      (if content-type
        response
        (assoc-in response [:headers "Content-Type"])))))

#'user/wrap-utf8-html

(let [a (set [1 3 2]) b #{1 2 3} c #{3 2 1}] (= a b c))

true

(reduce (fn [m [a b]] (let [item (m a [])] (assoc m a (conj item b))))
  {}
  '[[foo bar] [foo zonk] [bar foo]])

{bar [foo], foo [bar zonk]}

(defn dispatch-on-param
  [param handlers]
  (fn [{:keys [params], :as request}]
    (let [value (get params param)
          handler (get handlers value)]
      (handler request))))

#'user/dispatch-on-param

(let [nodes (range 6)
      decorators (-> (map (fn [a b] a) (repeat "|--") (rest nodes))
                     (concat ["`--"]))]
  (map str decorators nodes))

("|--0" "|--1" "|--2" "|--3" "|--4" "`--5")

(let [a (set (range 0 6))
      b (set (range 0 10 2))]
  (reduce #(if (a %2) (inc %) %) 0 b))

3

(let [f (fn foo [xs]
          (lazy-seq (when (seq xs) (cons (take 3 xs) (foo (drop 3 xs))))))
      v (f (range 20))]
  v)

((0 1 2) (3 4 5) (6 7 8) (9 10 11) (12 13 14) (15 16 17) (18 19))

(defmacro strs
  [& syms]
  (let [vs (vec (for [sym syms] (if (contains? &env sym) sym (str sym))))]
    `(clojure.string/join " " ~vs)))

#'user/strs

(let [counter (atom 0)]
  (nth (map (fn [i] (map #(swap! counter + %) (take 3 (repeat 1))))
         (iterate inc 0))
       1000))

(1 2 3)

(let [m {0 2, 1 3, 2 2, 3 2, 4 1, 5 3, 6 4, 7 7}] (assoc m 0 2))

{0 2, 1 3, 2 2, 3 2, 4 1, 5 3, 6 4, 7 7}

(defn fibn
  [n]
  (let [n (int n)]
    (if (>= (int 1) n) 1 (+ (fibn (dec n)) (fibn (- n (int 2)))))))

#'user/fibn

(defn swap!-old
  [a f & args]
  (let [old (atom nil)]
    (swap! a #(do (reset! old %) (apply f % args)))
    @old))

#'user/swap!-old

(let [r (range 10000000)]
  (loop [i (first r)
         r r]
    (when (< i 10) (print i) (recur (first (rest r)) (rest r)))))

nil

"0123456789"

(let [foo [1 1 1]]
  (second
    (reduce (fn [[a x] b] [a (and x (= a b))]) [true (first foo)] (rest foo))))

false

(let [kv-map (fn [f coll] (into {} (mapv (fn [[& kv]] (mapv f kv)) coll)))]
  (kv-map inc {1 10, 2 20, 3 31}))

{2 11, 3 21, 4 32}

(let [ls '(1 2 3 4 5)
      ls2 (concat ls '(6))]
  [ls ls2 (identical? (nth ls 3) (nth ls2 3))])

[(1 2 3 4 5) (1 2 3 4 5 6) true]

(let [data '[{:type dog, :attrs a, :val 3} {:type dog, :attrs b, :val 5}]]
  (:val (keep (comp #{'b} :attrs) data)))

nil

(let [subsets '(() ({:id 1}) ({:id 2}) ({:id 1} {:id 2}))]
  (map #(set (map vector (repeat :id) (map :id %))) subsets))

(#{} #{[:id 1]} #{[:id 2]} #{[:id 1] [:id 2]})

(let [foo [1 2 3]]
  (second
    (reduce (fn [[a x] b] [a (and x (= a b))]) [true (first foo)] (rest foo))))

false

(let [f '(nil nil "fizz")
      b '(nil nil nil nil "buzz")]
  (take 30 (map vector (range) (cycle f) (cycle b))))

([0 nil nil] [1 nil nil] [2 "fizz" nil] [3 nil nil] [4 nil "buzz"] [5 "fizz" nil] [6 nil nil] [7 nil nil] [8 "fizz" nil] [9 nil "buzz"] [10 nil nil] [11 "fizz" nil] [12 nil nil] [13 nil nil] [14 "fizz" "buzz"] [15 nil nil] [16 nil nil] [17 "fizz" nil] [18 nil nil] [19 nil "buzz"] [20 "fizz" nil] [21 nil nil] [22 nil nil] [23 "fizz" nil] [24 nil "buzz"] [25 nil nil] [26 "fizz" nil] [27 nil nil] [28...

(let [l (list :a 1 :b 2 :c 3)]
  (interleave (take-nth 2 l) (map #(* % 2) (take-nth 2 (rest l)))))

(:a 2 :b 4 :c 6)

(let [ms [{:id 1, :x 1} {:id 2, :x 2} {:id 1, :x 3}]]
  (->> ms
       (map (juxt :id identity))
       (into {})
       (vals)))

({:id 1, :x 3} {:id 2, :x 2})

(defn lazy-sort
  [& ls]
  (let [ls (sort-by first (remove empty? ls))]
    (cons (ffirst ls)
          (lazy-seq (apply lazy-sort (rest (first ls)) (rest ls))))))

#'user/lazy-sort

(do (defmacro map->
      [coll & clauses]
      (let [g (gensym)]
        `(for [~g ~coll]
           (-> ~g
               ~@clauses))))
    (map-> [1 2 3] inc even?))

(true false true)

(into {}
      (let [old {:a 1, :b 2}
            new {:a 1, :b 3}]
        (filter (fn [[k v]] (not (= (k old) v))) new)))

{:b 3}

(let [a [[1 2 3] [1 5 6]]
      b ["abc" "def"]]
  (into {} (mapcat #(map (fn [k] [k %2]) %1) a b)))

{1 "def", 2 "abc", 3 "abc", 5 "def", 6 "def"}

(let [in [{:hello [1]} {:hello [3]} {:hello [4]}]
      ks (distinct (mapcat keys in))
      init (zipmap ks (repeat []))]
  (apply merge-with conj init in))

{:hello [[1] [3] [4]]}

(let [registered (atom [])]
  (defn register [f & args] (swap! registered conj [f args]))
  (defn fire [] (doseq [[f args] @registered] (apply f args))))

#'user/fire

(let [m {(rand-int 1000) (rand-int 100),
         (+ 1000 (rand-int 1000)) (rand-int 100)}]
  (apply = (repeatedly 100 #(zipmap (keys m) (vals m)))))

true

(let [m {:a 1, :b 2} ms [m {:a 2, :b 4} m {:a 5, :b 9}]] ((frequencies ms) m))

2

(let [aside (fn [& args] (fn [& inner-args] (map #(%1 %2) args inner-args)))]
  (map (aside - str) (range 1 10) (range)))

((-1 "0")
  (-2 "1")
  (-3 "2")
  (-4 "3")
  (-5 "4")
  (-6 "5")
  (-7 "6")
  (-8 "7")
  (-9 "8"))

(let [m {"a" {:value "b"}, "foo" {:value "bar"}}]
  (reduce-kv (fn [s k v] (str k "=" (apply str (vals v)))) "" m))

"foo=bar"

(let [<3 (fn [love & loves]
           (loop [l (str "I love " love)
                  loves loves]
             (let [[love & loves] loves]
               (if (nil? love)
                 (str l ".")
                 (if (empty? loves)
                   (str l " and " love ".")
                   (recur (str l ", " love) loves))))))]
  (<3 "clojure" "cookies" "pizza"))

"I love clojure, cookies and pizza."

(let [n 500]
  (map
    #(let [halton (fn [idx base]
                    (loop [result 0
                           f (/ 1.0 base)
                           i idx]
                      (if (<= i 0)
                        result
                        (recur (+ result (* f (mod i base)))
                               (/ f base)
                               (int (/ i base))))))]
       (halton % 5))
    (range 20 521)))

(0.16 0.36 0.56 0.7600000000000001 0.9600000000000001 0.008 0.20800000000000002 0.40800000000000003 0.6080000000000001 0.808 0.048 0.24800000000000003 0.448 0.6480000000000001 0.8480000000000001 0.088 0.28800000000000003 0.48800000000000004 0.6880000000000001 0.888 0.128 0.328 0.528 0.7280000000000001 0.928 0.168 0.368 0.5680000000000001 0.7680000000000001 0.9680000000000001 0.016 0.21600000000000...

(let [a #(apply str (flatten %))
      r repeatedly
      n #(rand-nth %&)
      w (fn []
          (let [b (n "!" "..." "." "" "" "" "")
                s [(n "S"
                      "Z" "T"
                      "K" "N"
                      "Th" "Sh"
                      "Y" "P"
                      "K" "L"
                      "G" "Ny"
                      "Ft" "Cth")
                   (r (n 1 2)
                      #(vector (n "a" "i" "o" "e" "ia" "u" "ai")
                               (n "" "" "" "-" "'")
                               (n "l"
                                  "h" "s"
                                  "pr" "t"
                                  "rl" "n"
                                  "k" "gl"
                                  "g" "gh"
                                  "ts" "lt"
                                  "gr" "rk"
                                  "kh" "x"
                                  "sh" "ng")))
                   (n "urr" "ato"
                      "omkur" "iashi"
                      "oroth" "okh"
                      "yng" "otep"
                      "ilal" "ugu"
                      "" "")]]
            [b " " (if (seq b) s (.toLowerCase (a s)))]))]
  (re-find #"[A-Z].+" (a (r 200 w))))

"Liarki'rlurr. Pe-shiaglilal gerlokh! Shurkomkur nyiarke'xato... Ki-rkapromkur fta-ginugu. Thelilal ketsolomkur poprai'shugu! Shosiashi so't laigugu. Yigrikhurr la-xial nyu-prokh! Porli-hyng cthonugu cthia'rlailotep niashiah! Ne-ga'lyng. Nipriakokh so'hotep! Cthulato ctha'ltia-lt shanototep nihe'kh. Ga-gha-gl ke'n... Nirkiashi ge'xaiprokh gigokh laigrikurr! Nyiltugu... Koxurr cthialtu-pr sairlatil...