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

#'G__130600

(defrecord A [a b])

#'user/A

(let [a 1] [a])

[1]

(defn foo [a] a)

#'user/foo

(defn dump2 [a] (a))

#'user/dump2

(defn ↬ [a] a)

#'user/↬

(let [a :a] a)

:a

(let* [a :a] a)

:a

(let [a 5] a)

5

(if-let [a nil] a)

nil

(let [a 1] a)

1

(loop [a 1] a)

1

(for [a (rest (range 5)) b [a a a]] [b])

([1] [1] [1] [2] [2] [2] [3] [3] [3] [4] [4] [4])

(defn trouble
  [a]
  (if-let [a (compare a 5)]
    (1)
    (a)))

#'user/trouble

(let [a 10] [[a 1] '(a 1) (list a 1) `(a 1)])

[[10 1] (a 1) (10 1) (user/a 1)]

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

#'user/foo

(let [a 0 #_#_a 42] a)

0

(let [{:keys [a], :or {a "bar"}} {}] a)

"bar"

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

nil

"2\n"

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

nil

"2"

(let [a (Integer. "1000")] (identical? a a))

true

(let [a 42] ['(a) (list a)])

[(a) (42)]

(let [a 1] (let [b (inc a) a :parrot] [b a]))

[2 :parrot]

(filter odd? (mapcat (fn [a] [a a a]) [1 2 3]))

(1 1 1 3 3 3)

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

[2 1]

(loop [a 1] (if (< a 3) (recur (inc a)) a))

3

((fn f ([a] (f nil a)) ([b a] [a b])) nil)

[nil nil]

(let [a (atom 1)] [(hash a) (swap! a inc) (hash a)])

[189519051 2 189519051]

(let [a 3] `(a ~a (inc a) ~(inc a)))

(user/a 3 (clojure.core/inc user/a) 4)

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

#'user/foo

((fn f ([a] (f nil a)) ([b a] [a b])) 1)

[1 nil]

(defn cross [A B] (for [a A b B] [a b]))

#'user/cross

(for [a (rest (range 5))] (let [r [a a a]] r))

([1 1 1] [2 2 2] [3 3 3] [4 4 4])

(loop [a 1] (if (< a 10) (recur (inc a)) a))

10

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

7

(let [a 0xf000] (if (< a 0x8000) a (- a 0x10000)))

-4096

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

2

(let [a 5 b (* 2 a) a 2] a)

2

(for [a "™test"] a)

(\™ \t \e \s \t)

(let [a 0] a)

0

((fn [a] a) 0)

0

((fn [a] a) 100)

100

(let [a 2 b 1 [a b] (if (< a b) [a b] [b a])] (println a b))

nil

"1 2\n"

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

[2 2]

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

[1 2]

(let [a 10] ['{:val a} {:val a}])

[{:val a} {:val 10}]

(let [a {}] (identical? a (with-meta a {:foo 1})))

false

(let [a [Double/NaN]] (= (first a) (first a)))

true

(defprotocol A
  (foo
    ([obj a] [obj a b])))

{:methods #{#object
             [clojure.lang.MultiFn 0x2d0e5248 "clojure.lang.MultiFn@2d0e5248"]},
 :name user/A,
 :ns #object [sci.impl.vars.SciNamespace 0x37a47b18 "user"],
 :sigs {:foo {:arglists (([obj a] [obj a b])), :doc nil, :name foo}}}

(let [a ()] [(class (conj a 1)) (class a)])

[clojure.lang.PersistentList clojure.lang.PersistentList$EmptyList]