(let [f (atom (fn [] (println "Hello")))]
  (@f)
  (reset! f (fn [] (println "Goodbye World")))
  (@f))

nil

"Hello\nGoodbye World\n"

(let [space " "]
  (apply str (concat "I" space "worship" space "His" space "shadow")))

"I worship His shadow"

(let [[a b] (re-matches #"(\d+) (\d+)" "12 34")]
  (prn a)
  (prn 2))

nil

"\"12 34\"\n2\n"

(let [[x y :as z 1 2 3 whatever] (range 5)] [x y z])

[0 1 (0 1 2 3 4)]

(defn tree-depth-check-empty
  [branch? children empty root]
  (let [walk (fn walk [node]
               (if (branch? node)
                 (let [children (children node)]
                   (if (empty? children)
                     empty
                     (inc (reduce max (map walk children)))))
                 0))]
    (walk root)))

#'user/tree-depth-check-empty

(let [r 7]
  (reduce (fn [t [i w]] (let [t (+ t w)] (if (< r t) (reduced i) t)))
    0
    [[0 1] [1 2] [2 3] [3 4] [5 6]]))

3

(defmacro condf
  [expr & clauses]
  (let [x (gensym "x")]
    `(let [~x ~expr]
       (cond ~@(apply concat
                 (for [[p e] (partition-all 2 clauses)]
                   [(if (keyword? p) p `(~p ~x)) e]))))))

#'user/condf

(let [x 9
      y '(- x)]
  (println `y)
  (println ``y)
  (println ``~y)
  (println ``~~y))

nil

"user/y\n(quote user/y)\nuser/y\n(- x)\n"

(defmacro if-pred
  [form cond yes no]
  `(let [~'% ~form] (if (~cond ~'%) ~yes ~no)))

#'user/if-pred

(let [{:keys [a b c], :or {c 0}, :as args} {:a 1, :b 2}] args)

{:a 1, :b 2}

(let [s "a/b/c/d/e"] (map #(subs s 0 (inc %)) (range 0 (count s) 2)))

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

(let [flip (fn [f] (fn [& xs] (apply f (reverse xs))))] ((flip /) 2 4))

2

(defn foo
  [var]
  (let [m (meta var)] (symbol (name (:name m)) (name (ns-name (:ns m))))))

#'user/foo

(let [s [1 2 3]] (map (comp second vector) s (partition 2 1 (cycle s))))

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

(defmacro method-call
  [object method-name & params]
  (let [method-symbol (symbol method-name)]
    `(. ~object ~method-symbol ~@params)))

#'user/method-call

(let [a (atom [1 2 3])] (swap! a (partial filterv (fn [x] (not= x 2)))))

[1 3]

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

{:a 2, :b 3}

(let [{a 0, b 5} [:a :b :c :d :e :f :g :h]] [a b])

[:a :f]

(defmacro solve
  [vars queries]
  (let [quoted_vars (map #(quote %) vars)] `(l/run* ~quoted_vars ~@queries)))

#'user/solve

(drop 30
      (let [a (object-array 64)
            v (vec a)]
        (aset a 0 :hi)
        v))

(nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil)

(map #(str (let [n (int %)] (if (= n %) n %))) [9.0 4.25])

("9.0" "4.25")

(defn or-comp
  [args & fns]
  (let [results (for [fn fns] (fn args))] (some true? results)))

#'user/or-comp

(let [xs [[1 2] [3 4]]] (into {} (for [[k v] xs] [(keyword (str k)) v])))

{:1 2, :3 4}

(let [f (partial apply hash-map :opt1 42 :opt2 "bam")] (map f [[:a 1] [:b 2]]))

({:a 1, :opt1 42, :opt2 "bam"} {:b 2, :opt1 42, :opt2 "bam"})

(let [& [1 2 3] [& &] & [& &] & [& &] &] &)

(1 2 3)

(let [r (:repeat {:repeat 0} 0)] (if (< r 2) [r] (range 1 (inc r))))

[0]

(let [_ (print "hey, ") _ (print "party ") _ (print "people!") _ 5] _)

5

"hey, party people!"

(let [f (fn [s p r] (.replaceAll s p r))] (apply f "foo" ["o" "a"]))

"faa"

(defmacro nif
  [expr pos zero neg]
  `(let [expr# ~expr]
     (cond (pos? expr#) ~pos
           ..)))

#'user/nif

(let [m [[0 0] [0 0]]] (assoc m 0 (assoc (nth m 0) 0 1)))

[[1 0] [0 0]]

(defmacro if-pred
  [form condition yes no]
  `(let [result# ~form] (if (~condition result#) ~yes ~no)))

#'user/if-pred

(take 5
      (binding [*print-dup* true]
        (let [q (repeatedly (fn [] *print-dup*))]
          (doall (take 3 q))
          q)))

(true true true false false)

(let [l '([0 12] [1 23] [3 65]) v (repeat (count l) 0)] v)

(0 0 0)

(let [a '(a list)
      r (atom a)]
  (swap! r conj 'something)
  [a @r r])

[(a list) (something a list)
 #object
  [clojure.lang.Atom 0x2aa81bde {:status :ready, :val (something a list)}]]

(defmacro t
  [& body]
  `(let [b# (System/currentTimeMillis)
         ret# (do ~@body)]
     [ret# (- (System/currentTimeMillis) b#)]))

#'user/t

(let [p (promise)
      s (lazy-seq (cons @p nil))]
  (deliver p s)
  (identical? s (first s)))

true

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

[1 2]

(let [a (hash-map (Object.) 1)]
  [(assoc a (Object.) 2) (assoc a (key (first a)) 2)])

[{#object [java.lang.Object 0x13802062 "java.lang.Object@13802062"] 2,
  #object [java.lang.Object 0x1d47cdba "java.lang.Object@1d47cdba"] 1}
 {#object [java.lang.Object 0x1d47cdba "java.lang.Object@1d47cdba"] 2}]

(let [f (fn f [& params] (apply hash-map params))] (:b (f :a 3 :b 32)))

32

(let [x (atom 0)]
  (defn counter [] x)
  (defn tick [] (swap! x #(+ % 1))))

#'user/tick

(let [a (atom false) l (lazy-seq (swap! a not) nil)] [(first (cons 3 l)) @a])

[3 false]

(let [coll [nil false 0 ""]]
  (reduce #(when (= %2 :hooray) (reduced %2)) [] coll))

nil

(defmacro mm [arg] (let [[p q] arg] `(and (isa? 'x ~p) (isa? y ~q))))

#'user/mm

(let [m {:foo1 "bar1"} cond (= 1 1)] (cond-> m cond (assoc :foo2 "bar2")))

{:foo1 "bar1", :foo2 "bar2"}

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

false

(let [maxrange 100]
  (reduce + (distinct (concat (range 3 maxrange 3) (range 5 maxrange 5)))))

2318

(let [{:keys [a b], :as all} {:a 12, :b 34, :c 56}] [a b all])

[12 34 {:a 12, :b 34, :c 56}]

(let [plus (fn [x] (fn [y] (+ x y)))] (map (plus 3) [4 5 6]))

(7 8 9)

(let [a (into-array [1 2 3]) p (seq a) _ (aset a 0 2)] p)

(2 2 3)

(let [c (atom 0) _ (with-meta (map (fn [_] (swap! c inc)) (range 100)) {})] @c)

32