(let [m {:a (delay (do (println "Doing") (* 2 2)))}]
  (println "Before")
  (println (m :a))
  (println "After"))

nil

"Before\n#object[clojure.lang.Delay 0x18f54a1a {:status :pending, :val nil}]\nAfter\n"

(let [x (lazy-seq (cons (do (println "ein") 1)
                        (lazy-seq (cons (do (println "twei") 2) nil))))]
  (second x))

2

"ein\ntwei\n"

(let [val "foo"]
  (cond (re-find #"ar" val) "it contains 'ar'"
        (= val "foo") "the val is foo"))

"the val is foo"

(let [{:keys [a b c], :as m} {:a [5 6], :c [6 7]}] [a b c m])

[[5 6] nil [6 7] {:a [5 6], :c [6 7]}]

(let [{l true, g false} (group-by #(< % 5) [1 2 6 8])] ["Lt" l "Gt" g])

["Lt" [1 2] "Gt" [6 8]]

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

[1 2 3]

(let [defaults {:x nil, :y nil}
      potentially-bad {:x 1, :z 3}]
  (merge defaults (select-keys potentially-bad (keys defaults))))

{:x 1, :y nil}

(let [m {:a 1, :b 2, :c 3}] (into (empty m) (map (juxt key (comp inc val)) m)))

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

(defn character-seq
  [reader]
  (lazy-seq
    (let [value (.read reader)]
      (if (= value -1) nil (cons ((char value)) (character-seq reader))))))

#'user/character-seq

(let [r [:a :b :c]] (for [i r j r :when (neg? (compare i j))] (vector i j)))

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

(let [x (list '(1 2) '(3 4))] (map #(apply + %&) (first x) (second x)))

(4 6)

(let [the-map {:a "alpha", :b "beta"}]
  (update the-map 1 #(if (seq %) (conj % :new-thing) #{:new-thing})))

{1 #{:new-thing}, :a "alpha", :b "beta"}

(take-while some?
            (iterate #(let [li (.lastIndexOf % "/")]
                        (when (<= 0 li) (.substring % 0 li)))
                     "a/b/c/d/e"))

("a/b/c/d/e" "a/b/c/d" "a/b/c" "a/b" "a")

(let [m {:a [1 2 3], :b [1 2]}] (for [[k vs] m v vs] {k v}))

({:a 1} {:a 2} {:a 3} {:b 1} {:b 2})

(let [m {:a 0}]
  (cond-> m
    (contains? m :a) (assoc :a :foo)
    (contains? m :b) (assoc :b :bar)))

{:a :foo}

(let [base 17]
  (map #(inc (read-string
               (apply str "0" (drop-last (Integer/toString (dec %) base)))))
    (range 1 100)))

(1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 4
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 5
 6
 6
 6
 6
 6
 6
 6
 6
 6
 6
 6
 6
 6
 6)

(let [foo "foo & bar"]
  (str foo " isn't even a problem here, but nrepl.el pukes on it"))

"foo & bar isn't even a problem here, but nrepl.el pukes on it"

(let [data [[:a 1] [:a 2] [:b 3]]]
  (->> (for [[k v] data] {k [v]})
       (apply merge-with concat)))

{:a (1 2), :b [3]}

(defmacro when-lets
  [pairs & body]
  `(let [~@pairs]
     (when (and ~@(->> pairs
                       (partition 2)
                       (map first)))
       ~@body)))

#'user/when-lets

(let [i (atom 0)]
  {:filter (first (filter #(do (swap! i inc) (odd? %)) (range 100))), :i i})

{:filter 1, :i #object [clojure.lang.Atom 0x339d04c3 {:status :ready, :val 32}]}

(let [m {:a 1, :b 2}]
  (into {} (map (fn [[k v]] [k (m v)]) {"first" :a, "second" :b})))

{"first" 1, "second" 2}

(let [i (atom 0)]
  {:filter (first (filter #(do (swap! i inc) (odd? %)) (range 5))), :i i})

{:filter 1, :i #object [clojure.lang.Atom 0x48a30554 {:status :ready, :val 5}]}

(let [digits [1 2 3]
      bools [true false true]]
  (filter number? (map #(if %1 %2) bools digits)))

(1 3)

(let [a (atom [])]
  (clojure.walk/postwalk #(do (swap! a conj %) %) '(+ a (- b c)))
  @a)

[+ a - b c (- b c) (+ a (- b c))]

(let [big Double/MAX_VALUE]
  (= (* 0.5 2 big) (* (* 0.5 2) big) (* 0.5 (* 2 big))))

false

(let [a (atom 0)
      o (reify
          Object
            (toString [this] (swap! a inc) (str @a)))]
  [(str o) (str o)])

["1" "2"]

(take 10 (map first (iterate (fn [[t n]] (let [i (inc n)] [(+ t i) i])) [1 1])))

(1 3 6 10 15 21 28 36 45 55)

(let [foo [1 2 3 4]]
  (->> (map #(= %1 (inc %2)) foo (rest foo))
       (every? true?)))

false

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

[y [y (z)]]

(let [m {[0 0 1] [0 1 0], [0 1 0] [1 1 0]}] (m [0 1 0]))

[1 1 0]

(let [a (atom 0)]
  (clojure.walk/postwalk (fn [x] (swap! a inc) x)
                         '(dotimes [i 5] (println "Hello")))
  @a)

8

(let [a 0
      b (inc a)
      c (inc b)]
  (print a b c)
  (print a b)
  (print a))

nil

"0 1 20 10"

(take 10
      (let [p (promise)
            s (lazy-cat [0 1] @p)]
        (deliver p (map + s (rest s)))
        @p))

(1 2 3 5 8 13 21 34 55 89)

(defmacro bla
  [x fname]
  (let [f (fn [args] (println args) x)] `(defn fname [& ~'args] (~f ~'args))))

#'user/bla

(let [b (map (fn [x] (println x)) '(1 2 3))]
  (println "after map")
  (doall b)
  (doall b))

(nil nil nil)

"after map\n1\n2\n3\n"

(defn make-connection-thingy
  []
  (let [connections (atom [])]
    {:onconnect (fn [x] (swap! connections conj x)),
     :onmessage (fn [x] (println x))}))

#'user/make-connection-thingy

(defmacro use
  ([database & expressions]
   `(let [db (<open database stuff>)]
      (defn put ....)
      (defn get....)
      (do expressions))))

#'user/use

(let [[a b] (split-with #(not= 1 %) [5 6 1 2 1 3])] (concat a (next b)))

(5 6 2 1 3)

(let [value "foo"]
  (condp (fn [f _] (f value)) nil keyword? 1 symbol? 2 string? 3 number? 4))

3

(defmacro actor
  [message-sym & body]
  `(let [ch# (chan)]
     (go-loop [~message-sym (<! ch#)] ~@body (recur (<! ch#)))
     ch#))

#'user/actor

(let [vectors [[1 2 3] [4 5 6]]] (for [x vectors] (map #(get x %) [0 2])))

((1 3) (4 6))

(let [a (atom 1)]
  (println "atom is " @a)
  (swap! a (constantly 2))
  (println "atom is " @a))

nil

"atom is  1\natom is  2\n"

(let [base 36]
  (map #(inc (read-string
               (apply str "0" (drop-last (Integer/toString (dec %) base)))))
    (range 1 100)))

(1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 1
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 2
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3
 3)

(let [m {:a {:b {:c 1}}} x nil] (if (nil? x) m (update-in m [:a :b :d] x)))

{:a {:b {:c 1}}}

(let [m1 {:a 1, :b 2} m2 {:b 2, :c 3}] (remove #(contains? m2 %) (keys m1)))

(:a)

(let [data {:a 0, :b 1, :c {:d {:e 3}}} path '(:c :d :e)] (get-in data path))

3

(let [v [1 2 3 4 5] i 2] (into (subvec v 0 i) (subvec v (inc i))))

[1 2 4 5]

(defmacro <<-
  [& body]
  (let [wraps (butlast body)
        body (last body)]
    `(->> (do ~@body)
          ~@(reverse wraps))))

#'user/<<-

(let [x [1] y [1] z #{x y}] (map #(identical? % (get z [1])) [x y]))

(false true)

(let [ns [3 3.0 3.0M]] (for [a ns b ns] (str a \space b \space (== a b))))

("3 3 true"
 "3 3.0 true"
 "3 3.0 true"
 "3.0 3 true"
 "3.0 3.0 true"
 "3.0 3.0 true"
 "3.0 3 true"
 "3.0 3.0 true"
 "3.0 3.0 true")