(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 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

(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]}

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

#'user/strs

(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))

(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 [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}

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

(1 2 3)

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

nil

"0123456789"

(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 [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 [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 [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 [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 [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 [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

(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)

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

(true false true)

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

#'user/fire

(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 [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 {(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" {: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...