(let [a {} b {}] [(identical? (assoc a :a 1) (assoc a :a 1)) (identical? a b)])

[false true]

(loop [a 0
       s (range 10)]
  (if (empty? s)
    a
    (let [a (+ a (first s))] (when-not (= a 5) (recur a (next s))))))

45

((fn mine
   ([] (mine 0))
   ([a] (mine a 0))
   ([a b] (mine a b 0))
   ([a b c & args] (conj args c b a))))

(0 0 0)

(let [[{a :a}] [[:a :A]]] a)

nil

((quote #{a b}) (quote a))

a

(if-let [[a b] nil] [a b])

nil

(macroexpand '(let [a :a] a))

(let [a :a] a)

(let [{[a] :k} {:k [5]}] a)

5

(let [{:keys [a]} {:a 1}] a)

1

(let [[[[a]]] [[[42 43 44]]]] a)

42

(let [{:strs [a]} {"a" 1}] a)

1

(let [a 1] ((fn [] (inc a))))

2

(let [a 1] `(a ~a))

(user/a 1)

(map (fn [a] {:a a}) "aaaa")

({:a \a} {:a \a} {:a \a} {:a \a})

(class #(let [a 1] a))

sci.impl.fns$fun$arity_0__26683

(let [a 1] '(inc a))

(inc a)

(let [a "123"] (pr (.isEmpty a)))

nil

"false"

(let [a 'b] (def a 9))

#'user/a

(defn add [a b] "doc" {:pre [(even? a)]} (+ a b))

#'user/add

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

[1 2]

(let [a 5 b (+ a 5)] {:a a, :b b})

{:a 5, :b 10}

(for [a [1 2 3] x (assoc {} a (- a))] x)

([1 -1] [2 -2] [3 -3])

(let [a [5] b [5]] [(identical? a b) (set [a b])])

[false #{[5]}]

(let [a {:a 1}] (zipmap (keys a) (map inc (vals a))))

{:a 2}

(defn a [])

#'user/a

(defrecord a [])

#'user/a

(declare a)

#'user/a

(ns A)

nil

(let [a (hash-map Double/NaN 1)] (assoc a (key (first a)) "foo"))

{##NaN "foo"}

(let [a nil b [1]] (if a (conj b a) b))

[1]

(let [a [1 2 3]] (identical? a (with-meta a {:b 1})))

false

(let [a (hash-map Double/NaN 1)] (identical? (assoc a Double/NaN 2) a))

false

(let [a 2 b [1]] (if a (conj b a) b))

[1 2]

(quote A)

A

(let [a {}])

nil

(quote a)

a

(ns a)

nil

(let [a (atom 1)] (= [0 a 0] [0 a 0]))

true

(let [a 2 _ (println a) b 3] (+ a b))

5

"2\n"

(defn methornil [x f a] (if a (f x a) x))

#'user/methornil

(let [a (repeatedly 2 #(transient []))] (identical? (first a) (second a)))

false

(let [a (array-map Double/NaN 1)] (assoc a (key (first a)) "foo"))

{##NaN 1, ##NaN "foo"}

(defn mymod [a b] (- a (* (/ a b) b)))

#'user/mymod

(replace '{a x} '[a b c d e a])

[x b c d e x]

(let [{:syms [a b]} '{a 1, b 2}] [a b])

[1 2]

(for [a (range 1 4) b (range a)] [a b])

([1 0] [2 0] [2 1] [3 0] [3 1] [3 2])

(apply (fn ([a] a) ([a & more] (reverse more))) (range 10))

(9 8 7 6 5 4 3 2 1)

(defn cut-at [a b] (apply subs a 0 (replace {-1 (count a)} [(.indexOf a b)])))

#'user/cut-at

(loop [a 3 b 4] (if (= a 0) b (recur (rem b a) a)))

1

(letfn [(starling [a] (fn [b] (fn [c] ((a c) (b c))))) (kestrel [a] (fn [b] a))
        (identity [a] (((starling kestrel) kestrel) a))]
  (identity (rand-int 100)))

64