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

1

(let [a 3] #{a 3})

#{3}

(defn foo {:bar 1} [a] a)

#'user/foo

(defn ^long x [^long a] a)

#'user/x

(defprotocol test
  (foo
    ([a] [a b])))

{:methods #{#object
             [clojure.lang.MultiFn 0x10eb7544 "clojure.lang.MultiFn@10eb7544"]},
 :name user/test,
 :ns #object [sci.impl.vars.SciNamespace 0x37a47b18 "user"],
 :sigs {:foo {:arglists (([a] [a b])), :doc nil, :name foo}}}

((fn [[a b]] a) [1 2])

1

(let [a (long 3)] (class a))

java.lang.Long

(let [a (String. "hello")] (.toString a))

"hello"

(defn bind-atom [a] (def shadow-my-atom a))

#'user/bind-atom

(let [{:keys [a]} {:whatever/a 0}] a)

nil

(let [a 10] (+ a 23))

33

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

(nil nil nil nil)

"0123"

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

1

(let [a nil] (get a 1))

nil

(letfn [(b [] (a)) (a [] 2)]
  (b))

2

(let [a 3 b 4] a)

3

((fn [a a] 3) 1 2)

3

(let [{a "country"} {"country" "US"}] a)

"US"

(map (fn [a] a) {:a :b})

([:a :b])

((fn [_ a] a) 42 23)

23

(defn thrush [a b] (b a))

#'user/thrush

(let [a 5 b a] b)

5

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

2

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

(clojure.core/sequence (clojure.core/seq (clojure.core/concat (fn [a] a))))

(let [{a :foo} [:foo :bar]] a)

nil

(as-> 3 a (+ a 4))

7

(type (for [a (range 10)] a))

clojure.lang.LazySeq

(defn arg1 [a & r] a)

#'user/arg1

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

(clojure.core/let [user/a 1] user/a)

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

((1))

(let [a (gensym)] (= a (gensym)))

false

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

1

(list? (list* (for [a [1]] a)))

false

(defn rgcd [a b] (if (= a 0) b (rgcd (rem b a) a)))

#'user/rgcd

(defn ranger [a b] (if (< a b) (into [a] (ranger (inc a) b)) []))

#'user/ranger

(letfn [(my-odd? [a] (not (my-even? a)))
        (my-even? [a] (or (zero? a) (my-odd? (dec a))))]
  (map my-odd? (range 0 10)))

(false true false true false true false true false true)

(mapcat (fn [a b] (when (= a b) [a])) '(a b b b) '(a b c c))

(a b)

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

#'user/add

(let [a 1 b 2 a 3] (+ a b))

5

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

true

(let [a 1 b (inc a)] {:a a, :b b})

{:a 1, :b 2}

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

20

(defmacro rp [a] (list `time (list `println (str a) a)))

#'user/rp

((fn [{a :a, :or {a 0}, :as m}] [m a]) {})

[{} 0]

(defn x ([a b] (x a b 1)) ([a b c] (+ a b c)))

#'user/x

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

[2 2 1]

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

[{##NaN 1, ##NaN 2} {##NaN 2}]

(loop [a 10 acc nil] (if (zero? a) acc (recur (dec a) (conj acc a))))

(1 2 3 4 5 6 7 8 9 10)

(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 [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)}]]