(defn a [the-map] (the-map a))

#'user/a

(if-let [a (not-empty [])]
  a
  'made-it)

made-it

(if-let [a (inc 0)] a)

1

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

[nil nil]

(defn x [a] (println a))

#'user/x

(defn next [a] (inc a))

#'user/next

(case '(a) [a] 1)

1

(defn a [] (+ (a) 1))

#'user/a

(with-local-vars [a 1] (println a))

nil

"#'G__3421413\n"

(for [a [{:foo 1}]] a)

({:foo 1})

(if-let [a nil]
  a
  'd)

d

(doseq [a nil] (println a))

nil

(if-let [a false]
  a
  :not-a)

:not-a

(defn rrgcd [a b] (loop [a a b b] (if (= a 0) b (recur (rrgcd (rem b a) a)))))

#'user/rrgcd

(let [a (promise)]
  (deliver a 10)
  (deliver a 20))

nil

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

1

(defn foo [& {:keys [a], :or {a 1/2}}] a)

#'user/foo

(quote `(let [a b] ~@(fn [a] a)))

(clojure.core/sequence
  (clojure.core/seq
    (clojure.core/concat
      (clojure.core/list (quote clojure.core/let))
      (clojure.core/list
        (clojure.core/vec
          (clojure.core/sequence
            (clojure.core/seq (clojure.core/concat
                                (clojure.core/list (quote user/a))
                                (clojure.core/list (quote user/b)))))))
      (fn [a] a))))

(if true
  (defrecord A [a])
  (defrecord A [b c]))

#'user/A

(type (let [a (/ 1 3)] (/ a a)))

clojure.lang.BigInt

(let [a (transient {})] (identical? a (assoc! a :b :c)))

true

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

{:a 1}

(let [a "hi"] (with-out-str (println (let [a "123"]) a)))

"nil hi\n"

(if-let [a (+ 3 4)]
  (* a a)
  "no")

49

(let [a 0 f (fn [] a) a 1] (f))

0

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

2

(binding [*print-dup* true] (print (fn [a] (+ a a))))

nil

"#=(sci.impl.fns$fun$arity_1__26688. )"

(let [a (promise)]
  (deliver a 0)
  (deliver a 1))

nil

(let [eq? (fn [a] (identical? a a))] (eq? 1000))

true

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

1

(defn f ([a] (recur [a 0])) ([a b] b))

#'user/f

(let [a (Double/valueOf Double/NaN)]
  (identical? (.doubleValue a) (.doubleValue a)))

false

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

[{:a 1, :b 2} {:a 1}]

(let [a 0 b (inc a) a 2] b)

1

(let [a [0] b (conj a 1)] [a b])

[[0] [0 1]]

(let [a (transient {})] (= a (assoc! a :b :c)))

true

(for [a (range 10) :when (odd? a)] (inc a))

(2 4 6 8 10)

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

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

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

2

(loop [a 10] (if (not (zero? a)) (do (println a) (recur (dec a)))))

nil

"10\n9\n8\n7\n6\n5\n4\n3\n2\n1\n"

(let [a 1 b #(+ a %) a 2] (b a))

3

(loop [a 0] (if (>= a 5) a (recur (+ a (rand-int 5)))))

7

(let [a 1 f (fn [] a) a 2 f2 (fn [] a)] [(f) (f2)])

[1 2]

(defn do_not_ [a b] a)

#'user/do_not_

(let [a :bar] (prn a))

nil

":bar\n"

(let [a 1] (list a))

(1)

(defrecord A [a b c])

#'user/A

(if-let [a nil]
  a
  nil)

nil

(if-let [a nil]
  a
  :not-a)

:not-a

(let [a 3] (class a))

java.lang.Long