(quote [a b c])

[a b c]

(def a '(3))

#'user/a

(list '(a b))

((a b))

(defn f [{:keys [a]}])

#'user/f

(defn a [] [20 30])

#'user/a

(if-let [a true] 10)

10

(def a (atom "a"))

#'user/a

(defrecord r [a b])

#'user/r

(meta (defn a [] 3))

{:arglists ([]),
 :column 7,
 :file nil,
 :line 1,
 :name a,
 :ns #object [sci.impl.vars.SciNamespace 0x37a47b18 "user"]}

(declare a b c)

#'user/c

(let [a (atom 3)])

nil

(defrecord F [a b])

#'user/F

(def a {:a 2})

#'user/a

(print "I'm a n00b")

nil

"I'm a n00b"

(class (set '(a)))

clojure.lang.PersistentHashSet

(clojure.core/defrecord n [a b])

#'user/n

(defrecord R [a b])

#'user/R

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

#{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 ^:dynamic a 1)

#'user/a

(macroexpand-1 '(foo (a)))

(foo (a))

(def ^:xyz a 1)

#'user/a

(list? '[a 1])

false

(def a (set [1]))

#'user/a

(defn thing [^:foo a])

#'user/thing

(def a #(%))

#'user/a

(let [a 23] (doseq [b (range 24)] (print (mod (min (- a b) (- b a)) 24))))

nil

"12345678910111213141516171819202122230"

(reduce (fn [[a v] k] [(get a k) (conj v k (get a k))]) [{} []] [:a :b :c])

[nil [:a nil :b nil :c nil]]

(do (defrecord R [a b])
    (defn foo [f a b] (f a b))
    (foo ->R 1 2))

#user.R {:a 1, :b 2}

(let [a (Object.)
      b (Object.)]
  {a {:name "foo", :other b}, b {:name "bar", :other a}})

{#object [java.lang.Object 0x6238357d "java.lang.Object@6238357d"]
   {:name "bar",
    :other #object [java.lang.Object 0x6cffc692 "java.lang.Object@6cffc692"]},
 #object [java.lang.Object 0x6cffc692 "java.lang.Object@6cffc692"]
   {:name "foo",
    :other #object [java.lang.Object 0x6238357d "java.lang.Object@6238357d"]}}

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

[4 2]

(let [a [1 2 3] b [0 0 0 0 0]] (into a (subvec b (count a))))

[1 2 3 0 0]

(let [a (long-array [0 1 2 3 4])]
  (= (seq (amap a i _ (inc (aget a i))))
     (seq (amap a i r (aset r i (inc (aget a i)))))))

true

(do (use 'clojure.set)
    (let [a (ancestors (type 'wheeee))
          b (ancestors (type :wheeee))]
      {:a-b (clojure.set/difference a b),
       :b-a (clojure.set/difference b a),
       :a*b (clojure.set/intersection a b)}))

{:a*b #{clojure.lang.IFn clojure.lang.IHashEq clojure.lang.Named
        java.io.Serializable java.lang.Comparable java.lang.Object
        java.lang.Runnable java.util.concurrent.Callable},
 :a-b #{clojure.lang.AFn clojure.lang.IMeta clojure.lang.IObj},
 :b-a #{}}

(defn diviser
  ([a b] "divide a with b" {:pre [(not= b 0)]} (/ a b))
  ([a b] {pre [(= b 0)]} (println "nope")))

#'user/diviser

(defmacro a [] (prn &env))

#'user/a

(defn a [args handler])

#'user/a

(defrecord A [x y])

#'user/A

(println "I'm a bot")

nil

"I'm a bot\n"

(seq? `'[a 1])

true

(def a (object-array 100000))

#'user/a

(def a (atom 3))

#'user/a

(meta (quote ^:a a))

{:a true}

('a '{a 1})

1

(defrecord Stuff [a b])

#'user/Stuff

(macroexpand-1 '(foo. a))

(foo. a)

(defrecord Storage [a b])

#'user/Storage

(let [a +] 'a)

a

(println "[A]")

nil

"[A]\n"

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

#'user/a

(seq "I'm a string")

(\I \' \m \space \a \space \s \t \r \i \n \g)