(print (first (remove #(> % 0.5)
                (repeatedly (fn []
                              (let [r (rand)]
                                (print r " ")
                                r))))))

nil

"0.3131226424453881  0.3131226424453881"

(let [v [1 2 3 4 5 6] [a b] (split-at 3 v)] (concat a (next b)))

(1 2 3 5 6)

((fn [& all]
   (let [xall (butlast all)
         last2 (last all)]
     (doall (map #(let [a %] (if (fn? a) (a) a)) xall))
     (last2)))
  #(println 1)
  #(do 2)
  #(do 3)
  4
  #(do 5))

5

"1\n"

(defn int*
  [x]
  (let [i (bit-and 0x7fffffff x)]
    (Integer. (if (< x 0x8000000) x (+ -0x80000000 i)))))

#'user/int*

(let [xs (lazy-seq (iterate inc 0))
      pre (realized? xs)
      x (first xs)
      post (realized? xs)]
  [pre post])

[false true]

(let [vec-order (zipmap [:b :c :a] (range))]
  (into (sorted-map-by (comparator vec-order)) {:a 1, :b 5, :c 6}))

{:a 1, :b 5, :c 6}

(let [r [:a :b :c]] (for [i r j r :when (not= i j)] (vector i j)))

([:a :b] [:a :c] [:b :a] [:b :c] [:c :a] [:c :b])

(let [pred #{4}
      coll (range)]
  (reduce #(if (pred %2) (reduced %1) (inc %1)) 0 coll))

4

(let [m1 {:k 1} m2 {:k 2} {k1 :k} m1 {k2 :k} m2] [k1 k2])

[1 2]

(let [l (range 1 5)] (map (fn [i] [(take i l) (drop i l)]) (range (count l))))

([() (1 2 3 4)] [(1) (2 3 4)] [(1 2) (3 4)] [(1 2 3) (4)])

(let [c [1 1 2 3 3 4]] (every? #{0 1} (map - (rest c) c)))

true

(let [mymap {'x 2, 'y 3}] (map #(get mymap % %) '(+ 1 x y)))

(+ 1 2 3)

(let [a (into-array [1 2 3])
      v (vec a)]
  (aset a 0 42)
  [(seq a) v])

[(42 2 3) [42 2 3]]

(let [x {:holder (atom nil)}
      x-holder [x]]
  (swap! (:holder x) (constantly x-holder))
  (identical? x-holder @(:holder x)))

true

(let [{:keys [a b c], :or {a 1, b 2, c 3}} {:a 10}] [a b c])

[10 2 3]

(let [m {:a 1, :b 2, :c 3}] (reduce #(update-in %1 [%2] inc) m (keys m)))

{:a 2, :b 3, :c 4}

(let [a (atom '[x [y z]])] (first (swap! a (fn [[_ [f & more]]] [f more]))))

y

(let [ds {:coms [{:zr-com-data {:sub-coms []}}]}]
  (assoc-in ds [:coms 0 :zr-com-data :sub-coms 0 :a 0 0 :p] "hi"))

{:coms [{:zr-com-data {:sub-coms [{:a {0 {0 {:p "hi"}}}}]}}]}

(let [[a b c :as x] [1 nil 2]] (if (every? identity x) [a b c] :otherwise))

:otherwise

(let [funcall (fn [f & args] (apply f args))] (map funcall [+ -] [1 1] [1 1]))

(2 0)

(let [f (fn [& {:as opts}] ((juxt :foo :bar) opts))]
  (f :hello 10 :bar 42 :foo :quux))

[:quux 42]

(defmacro ?
  [x]
  `(let [x# ~x]
     (printf "%s is %s" (pr-str x#) ~(pr-str x))
     x#))

#'user/?

(let [orig {:a 1, :b 2}] (merge orig (select-keys [:c :g] {:c 3, :d 4, :g 5})))

{:a 1, :b 2}

(let [{:keys [a b c], :as m} {:a 1, :b 2, :c 3}] (assoc m :a 3))

{:a 3, :b 2, :c 3}

(defmacro condv
  [v & clauses]
  `(let [v# ~v] (condp (fn [f# _#] (f# v#)) nil ~@clauses)))

#'user/condv

(let [x (concat (do (println 1) [1]) (do (println 2) [2]) (do (println 3) [3]))]
  (first x))

1

"1\n2\n3\n"

(let [a 1 b 2 c 3] (map (fn [e] (keyword (:name (meta #'e)))) [a b c]))

(nil nil nil)

(let [m {:foo 7, :bar 8, :baz 7}]
  (->> m
       (filter (comp #{7} val))
       (map key)))

(:foo :baz)

(let [a {:a 0, :b 1}] (= a (select-keys {:a 0, :b 1, :c 2} (keys a))))

true

(let [[a b c :as d :as e] [1 2 3 4 [5 6]]] [a b c])

[1 2 3]

(let [m {:a 1, :b 3, :c 2} target 3] (filter #(= (val %) target) m))

([:b 3])

(let [{x 3, y 8} [12 0 0 -18 44 6 0 0 1]] (+ x y))

-17

(let [idx (partition 3 (range 9))]
  (concat idx (map list idx) [[0 4 8] [2 4 6]]))

((0 1 2) (3 4 5) (6 7 8) ((0 1 2)) ((3 4 5)) ((6 7 8)) [0 4 8] [2 4 6])

(let [filter-first (fn filter-first [pred coll]
                     (lazy-seq
                       (when-let [s (seq coll)]
                         (let [fst (first s)]
                           (if (pred fst)
                             (next s)
                             (cons fst (filter-first pred (rest s))))))))]
  (filter-first #(= 1 %) [9 6 1 3 1]))

(9 6 3 1)

(defmacro with-req-body
  [[binding] req & body]
  `(with-open [r# (~req :body)]
     (let [~binding (BufferedReader. (InputStreamReader. r#))] body)))

#'user/with-req-body

(let [[a b c d] (re-matches #"(c)([aeo]{3})(l)" "coool")] [a b c d])

["coool" "c" "ooo" "l"]

(let [m (apply hash-map (interleave (range 1000) (range 1000 2000)))]
  (= m (zipmap (keys m) (vals m))))

true

(let [counter (atom 0)]
  (last (repeatedly 1000 (fn [] (map #(swap! counter + %) (repeat 3 1))))))

(1 2 3)

(let [a (Object.)
      b (Object.)]
  {a {:name "foo", :other b}, b {:name "bar", :other a}})

{#object [java.lang.Object 0x6238357d "java.lang.Object@6238357d"]
   {:name "bar",
    :other #object [java.lang.Object 0x6cffc692 "java.lang.Object@6cffc692"]},
 #object [java.lang.Object 0x6cffc692 "java.lang.Object@6cffc692"]
   {:name "foo",
    :other #object [java.lang.Object 0x6238357d "java.lang.Object@6238357d"]}}

(reduce (fn [acc x] (let [x' (* x x)] (if (> x' 10) (reduced x') x'))) (range))

16

(let [coll #{nil 1 false 2}]
  (= coll (set (mapcat #(% identity coll) [filter remove]))))

true

(let [op (eval (first '(+ 1 2))) rst (rest '(+ 1 2))] (apply op rst))

3

(defn is
  [& things]
  (let [preds (map #(fn [x] (= x %)) things)] (apply some-fn preds)))

#'user/is

(let [[a b c d] [1 2 3 4]] {:a a, :b b, :c c, :d d})

{:a 1, :b 2, :c 3, :d 4}

((fn [& opts] (let [{:keys [a b], :or {a 1, b 2}} opts] [a b])) :a 4)

[4 2]

(let [m {:a 3, :b 3, :c 2} target 3] (filter #(= (val %) target) m))

([:a 3] [:b 3])

(defn atom-pop
  [a]
  (let [p (promise)]
    (swap! a #(do (deliver p (first %)) (pop %)))
    @p))

#'user/atom-pop

(let [a [1 2 3] b [0 0 0 0 0]] (into a (subvec b (count a))))

[1 2 3 0 0]

(map-indexed #(assoc %2 :index %1) (let [b {:p 19} a {:p 8, :s b}] [a b]))

({:index 0, :p 8, :s {:p 19}} {:index 1, :p 19})

(let [m {:a 1, :b 2, :d 4} {:keys [a b c]} m] [a b c])

[1 2 nil]