(if-let [a 6]
  5
  6
  7)

5

(macroexpand-1 '(declare a b c))

(do (def a) (def b) (def c))

(get '(a b c) 0)

nil

(seq? (concat '(a) '(b)))

true

(let* [a (if 1 (do 2))])

nil

(if (next '(a)) true false)

false

(macroexpand '(defstep :a {} (a) (b)))

(defstep :a {} (a) (b))

(macroexpand '(defrlf a b 10))

(defrlf a b 10)

(def a [0 1 2 3])

#'user/a

(macroexpand-1 '(-> x (map a)))

(map x a)

(macroexpand '(and a b c))

(and a b c)

(into {} '([a b] [c d]))

{a b, c d}

(macroexpand '(with-open [a foo] stuf))

(clojure.core/let [a foo]
  (try (clojure.core/with-open [] stuf) (finally (.close a))))

(defrecord A [^int i ^int j])

#'user/A

(macroexpand-1 '(-> b (a c)))

(a b c)

(map-indexed vector '(a b c))

([0 a] [1 b] [2 c])

(nth '(a b c) 0)

a

(list* (set '(a b c)))

(a c b)

(defmacro a [f] `(prn '~f))

#'user/a

((fn [a b] b) 0 5)

5

(macroexpand-1 '(-> a (b c)))

(b a c)

(re-seq #"\w" "Have a nice day")

("H" "a" "v" "e" "a" "n" "i" "c" "e" "d" "a" "y")

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

0

(macroexpand `(-> a
                  f1
                  f2))

(user/f2 (user/f1 user/a))

('#{1 2 a b} 1)

1

(def ^{:foo (println "foo")} a)

#'user/a

"foo\n"

(def a '(1 2 3))

#'user/a

(defmacro test-macro [s] `(a ~s))

#'user/test-macro

(macroexpand `(-> a
                  f1
                  (f2)))

(user/f2 (user/f1 user/a))

(def #^{:doc "my docstring"} a)

#'user/a

(defrecord Foo [a b c d])

#'user/Foo

(read-string "(./join a bc)")

(./join a bc)

(def #^{:doc "foo"} a 1)

#'user/a

(macroexpand-1 '(-> a b c))

(c (b a))

(contains? '[a b c] 1)

true

(macroexpand '(-> 1 (a b)))

(a 1 b)

(str '[a b c d])

"[a b c d]"

(let [^{a b} foo []] foo)

[]

('[a b c d] 2)

c

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

nil

"nil\n"

(try (let [a (keys [1])] :ok))

:ok

(defrecord YourRecord [name a b c])

#'user/YourRecord

(defn foo
  [a]
  (-> inc
      inc))

#'user/foo

(let [[a b c] (range)] c)

2

(macroexpand `(-> a
                  f1
                  ((f2))))

((user/f2) (user/f1 user/a))

(def a {:a 1, :b 2})

#'user/a

(type (concat '(a) '(b)))

clojure.lang.LazySeq

(into '() '((a) (b) (c)))

((c) (b) (a))

(do (let [a 3] (println `~a)))

nil

"3\n"

(try (defmacro foo [a] `~a) 1)

1