((fn [& {:keys [a b]}] [":a" a ":b" b]) {:a 1, :b 2})

[":a" 1 ":b" 2]

({(fn [a b] (a b)) 2, (fn [x] x) 1} (fn [x] x))

nil

(let [[a op b] (read-string "[1 + 1]")] (op a b))

1

(let [a 0 b (inc a) c (inc b) d (inc b)] d)

2

(defn in-interval? [a b] (fn [x] (and (>= x a) (<= x b))))

#'user/in-interval?

(let [[a b & rest] (iterate inc 0)] [a b (take 3 rest)])

[0 1 (2 3 4)]

((fn [s] (when-let [[a b c] (re-seq #"\w+" s)] [a b c])) "alpha.beta.com")

["alpha" "beta" "com"]

(let [{a' :a, {:keys [a]} :b} {:a 0, :b {:a 1}}] [a a'])

[1 0]

(defn compare-doubles [a b] :probably-different)

#'user/compare-doubles

(macroexpand '(-> a #()))

(fn* a [] ())

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

(let [[a] [1]])

(case 'a (a b) 1)

1

(first `[a b c])

user/a

(defn a [x] (.foo x))

#'user/a

(rest (rest '(a b)))

()

(if-let [[a b] nil] 20)

nil

('#{a b c} 'd)

nil

(defrecord Foo [a b c])

#'user/Foo

(= '(a) '(1))

false

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

nil

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

nil

(let* [a (when 1 2)])

nil

(rest '(a b c))

(b c)

(quote (quote (quote (b a))))

(quote (quote (b a)))

(macroexpand '(def a #()))

(def a (fn* [] ()))

(quote (quoted a b c))

(quoted a b c)

(def ^{:dynamic true} a)

#'user/a

(print "I'm still a n00by")

nil

"I'm still a n00by"

(macroexpand-1 '(and a b))

(and a b)

(def a (def x 1))

#'user/a

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

((fn []) a)

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

nil

(macroexpand-1 ''(a macro thingy))

(quote (a macro thingy))

(println "what's a coma for?")

nil

"what's a coma for?\n"

(defn myfn [[a & b]])

#'user/myfn

(defrecord foo [a b c])

#'user/foo

(defrecord Heyo [a b c])

#'user/Heyo

(re-matches #"(a)" "asdf")

nil

((fn [a b]) 1 nil)

nil

(let [f (fn [& {:keys [a]}] a)] ((partial f :a 1) :a 2))

2

(let [a (atom {:a {:b 1}})]
  (swap! a update-in [:a :b] inc)
  @a)

{:a {:b 2}}

(do (def a 1) (let [f (comp #'a)] (with-redefs [a (constantly 2)] (f))))

2

(let [[a b] (split-at 2 [1 2 3 4])] (concat a (rest b)))

(1 2 4)

(letfn [(a [x] (b (b x))) (b [x] (+ x 21))]
  (a 0))

42

(def op #(fn [a b] (fn [x] (% (a x) (b x)))))

#'user/op

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

[0 1]

(let [a (atom [{} nil])] (swap! a (fn [[m]] [(assoc m :foo :bar) m])))

[{:foo :bar} {}]

(for [a [1 2 3] b [1 2 3]] {:a a, :b b})

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

(into {} (map (fn [[a b]] (hash-map a b)) '(["1" "a"] ["2" "b"])))

{"1" "a", "2" "b"}

(let [a (sorted-map :a 1 :b 2 :c 3) k (keys a)] k)

(:a :b :c)