(macroexpand-1 '(dosync a b))

(dosync a b)

(re-seq #"(a)\4" "aba\\4")

nil

(defn a [afn] (afn 1))

#'user/a

(defmacro a [& args] `'~args)

#'user/a

(defn length ([] 0) ([a] 1))

#'user/length

('[a b c] 2)

c

(defrecord Bla [a b c])

#'user/Bla

(def a (make-array Integer 3))

#'user/a

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

#'user/a

(def a (repeat 5 (transient [])))

#'user/a

(second '(a b c))

b

(let [a 3 b 4])

nil

(defn munge [a b c])

#'user/munge

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

#'user/a

(let [a :one b a a :two c a] (str "b is " b " and c is " c))

"b is :one and c is :two"

(let [a (make-array Double/TYPE 5 5)]
  (aset a 2 4 0.9)
  (println (aget a 2 4))
  (let [b (aclone a)]
    (aset b 2 0 -9.3)
    (println (aget b 2 0))
    (println (aget a 2 0))))

nil

"0.9\n-9.3\n-9.3\n"

(let [a 10 b 20] (doall (doseq [num [a b]] (println num))))

nil

"10\n20\n"

(let [{:keys [a b]} {:a 2, :b 2, :c 3}] [b a])

[2 2]

(doseq [[a b] (map vector [[1 2] [3 4]])] (println a b))

nil

"[1 2] nil\n[3 4] nil\n"

(and "underdev is a strikingly handsome man" "underdev is a giving lover")

"underdev is a giving lover"

(let [plus (fn [a b] (+ a b))] (reductions plus (range 5)))

(0 1 3 6 10)

(mapcat (fn [a] (mapcat (fn [b] [[a b]]) [:a :c])) (range 3))

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

(for [[a b] (partition 2 [1 2 3 4])] (list b a))

((2 1) (4 3))

(map (fn [a b] [a b]) [1 2 3] (iterate inc 0))

([1 0] [2 1] [3 2])

(let [[a b] (re-matches #"a(b)c" "abc")] [:a a :b b])

[:a "abc" :b "b"]

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

[1 2]

(let [a {:a :b, :c :d}] (str (doall (map reverse (into [] a)))))

"clojure.lang.LazySeq@bc3043e0"

(into (sorted-map) (map (fn [[a b]] [b a]) {:a 1, :b 2}))

{1 :a, 2 :b}

(let [[a b] (repeatedly #(atom 0))] ((juxt = identical?) a b))

[false false]

(for [a (apply map list (partition 3 (range 15)))] (take 2 a))

((0 3) (1 4) (2 5))

(let [a '(fn [x] x) b (fn [x] x)] [a b])

[(fn [x] x)
 #object
  [sci.impl.fns$fun$arity_1__26688 0x719c39ae
   "sci.impl.fns$fun$arity_1__26688@719c39ae"]]

(let [a (atom {:x #{1}})] (swap! a update-in [:x] conj 2))

{:x #{1 2}}

(defmacro m [double a b c] `(do-something ~@double a b c))

#'user/m

(let [[a & more] [1] [b & rest] []] [more rest a b])

[nil nil 1 nil]

((fn [a b] (+ a b)) 1 1)

2

(apply merge-with into (for [[a b] [[:x 1] [:x 2]]] {a [b]}))

{:x [1 2]}

(apply (fn [& {:keys [a b c]}] a) (apply concat {:a 5}))

5

(reduce (fn [a b] (str a " " b)) ["a" "b" "c"])

"a b c"

(let [a 1] (map #(+ a %) [1 2 3 4]))

(2 3 4 5)

(take 10 (iterate (fn [[a b]] [b (+ a b)]) [0 1]))

([0 1] [1 1] [1 2] [2 3] [3 5] [5 8] [8 13] [13 21] [21 34] [34 55])

(take 10 (iterate (fn [[a b]] [b (+ a b)]) [1 1]))

([1 1] [1 2] [2 3] [3 5] [5 8] [8 13] [13 21] [21 34] [34 55] [55 89])

(apply (fn [a b & c] [a b (first c)]) (repeat 42))

[42 42 42]

(apply concat (for [a [{:a [0 1]} {:a [:b :c]}]] (:a a)))

(0 1 :b :c)

(for [a [[1 2 3] [4 5 6]] b a] (inc b))

(2 3 4 5 6 7)

(let [{:keys [a b & c]} {:a 1, :b 2}] [a b])

[1 2]

(defn mmap
  [m f a]
  (->> m
       (f a)
       (into (empty m))))

#'user/mmap

(defn pairs [a b] (for [x a y b] (list x y)))

#'user/pairs

(let [{a 0, b 1, :or {b 43}} (seq [42])] [a b])

[nil 43]

(defn foo [a b & [moose]] (+ a b (or moose 32)))

#'user/foo

((fn [a b & more] [a b [more]]) 1 2 [3 4])

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