(meta (first '[^:a a]))

{:a true}

(defmacro foo [a & more])

#'user/foo

(def a (def b 0))

#'user/a

(re-find #"(a)?1234|x" "xyz")

["x" nil]

(first '(a b c))

a

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

true

(let [a 1] (def b))

#'user/b

(defrecord Message [a b c])

#'user/Message

(macroexpand '(and A B))

(and A B)

(def a (atom [0 0]))

#'user/a

(defn a [] (in-ns 'foo) ::bar)

#'user/a

(defrecord test-record [a b c])

#'user/test-record

(defn a ([x] 1) ([] 2))

#'user/a

(print-str '(a b c))

"(a b c)"

(let [a (when 1 2)])

nil

(def a (take 40000000 (range)))

#'user/a

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

nil

('#{a b c} 'b)

b

(defmacro a [& b] `~b)

#'user/a

(defn a [n] (n 1))

#'user/a

(macroexpand '(-> a (fn [])))

(fn a [])

(symbol "Once upon a time...")

Once upon a time...

(coll? '(a b c))

true

(defn a [x y &z])

#'user/a

(next (next '(a b)))

nil

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

nil

"1\n"

(get `{a 2} 'a)

nil

(class '[a b c])

clojure.lang.PersistentVector

(map namespace '(a a/b))

(nil "a")

((fn [a & args]) 1)

nil

(macroexpand '(fn [[a] [1]]))

(fn [[a] [1]])

(test "this is a test")

:no-test

(def a (atom '(fn [])))

#'user/a

(associative? '[a b c])

true

(def a (atom [1 2]))

#'user/a

(defrecord X [a b c])

#'user/X

(re-seq #"(a)\1" "aa\\4")

(["aa" "a"])

(#_"this is a comment")

()

(macroexpand '(or a b))

(or a b)

(let [a 1 b 2])

nil

(set '(a b c))

#{a b c}

(clojure.walk/macroexpand-all '(or a b))

(or a b)

(supers (class (fn [a b])))

#{clojure.lang.AFn clojure.lang.AFunction clojure.lang.Fn clojure.lang.IFn
  clojure.lang.IMeta clojure.lang.IObj java.io.Serializable java.lang.Object
  java.lang.Runnable java.util.Comparator java.util.concurrent.Callable}

(def a {1 2, 3 4})

#'user/a

(let [a 1 b 2])

nil

(get `{a 2} `a)

2

(quote (quote (a b c)))

(quote (a b c))

(seq "Have a nice day.")

(\H \a \v \e \space \a \space \n \i \c \e \space \d \a \y \.)

(mapv type '[a b])

[clojure.lang.Symbol clojure.lang.Symbol]

(declare a b c d)

#'user/d