(for [a (range 3) b (range 3) :when (= a b)] {:a a, :b b})

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

(let [a (into-array [1 2 3]) p (seq a) _ (aset a 0 1)] p)

(1 2 3)

(let [a (list 1 2 3) b (cons 4 a)] (identical? a (rest b)))

true

(let [a 1 b 2 c 3] [(list a b c) '(a b c)])

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

(map (fn [a] (some #(when (= a %) [a %]) (range 4))) (range 4))

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

((fn [a b] (if (> (.length a) (.length b)) b (.compareTo a b))) "a" "b")

-1

(for [a (range 10) :when (= (* (- a 2) 6) 18)] (- a 2))

(3)

(for [a [1 2 3 1] :while (< a 3) b [:foo :bar]] [b a])

([:foo 1] [:bar 1] [:foo 2] [:bar 2])

(for [a [1 2 3 1] b [:foo :bar] :while (< a 3)] [b a])

([:foo 1] [:bar 1] [:foo 2] [:bar 2] [:foo 1] [:bar 1])

(let [s #{"a" "b" "c"}] (for [a s b (disj s a)] [a b]))

(["a" "b"] ["a" "c"] ["b" "a"] ["b" "c"] ["c" "a"] ["c" "b"])

(apply (fn [& {:keys [a b], :or {a 3, b 4}}] [a b]) {:b 2})

[3 4]

(let [+ (fn [a b] (if (odd? a) (+ a b) (- a b)))]
  (+ 1 2)
  (+ 2 2))

0

(let [a [1 2]
      b [3 4 5 6]]
  (concat (interleave a) (drop (count a) b) (drop (count b) a)))

(1 2 5 6)

(reduce (fn [a n] (if (> n 10) (reduced a) (+ n a))) 0 (range))

55

(letfn [(f [coll] (for [a coll] [a (remove #{a} coll)]))]
  (f [:foo :bar :baz]))

([:foo (:bar :baz)] [:bar (:foo :baz)] [:baz (:foo :bar)])

(drop 30
      (let [a (object-array 64)
            v (vec a)]
        (aset a 0 :hi)
        v))

(nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil
 nil)

(map (fn [a] [:name (a 0) :hp (a 1)]) [["foo" 20] ["moo" 30] ["boo" 20]])

([:name "foo" :hp 20] [:name "moo" :hp 30] [:name "boo" :hp 20])

(let [a (into-array [1 2 3]) p (seq a) _ (aset a 0 2)] p)

(2 2 3)

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

[1 2]

(let [a (into-array [1 2 3])
      s (seq a)]
  (aset a 1 5)
  s)

(1 5 3)

(let [a (into-array (range 5))
      v (into [] a)]
  (aset a 0 17)
  (get v 0))

0

(let [a '(1 2) b (cons 0 a) c (rest b)] (identical? a c))

true

(let [a {:a {:deep :map}} b {:b 1}] [(assoc b :foo (:a a)) b a])

[{:b 1, :foo {:deep :map}} {:b 1} {:a {:deep :map}}]

(let [a (object-array 5)
      v (conj (vec a) :end)]
  (aset a 0 :hi)
  v)

[nil nil nil nil nil :end]

(let [a [1 2]
      b [3 4 5 6]]
  (concat (interleave a b) (drop (count a) b) (drop (count b) a)))

(1 3 2 4 5 6)

(map #(apply (fn [a & b] (if b [a (first b)] [(dec a) a])) %)
  (partition-all 2 (range 1 16)))

([1 2] [3 4] [5 6] [7 8] [9 10] [11 12] [13 14] [14 15])

(clojure.string/replace "xyz" #"x(.)z" (fn [[_ a]] a))

"y"

(defn foo [a] (fn [x] (aset a 0 x)))

#'user/foo

(for [a [0 1] b (range 10)] [a b])

([0 0]
 [0 1]
 [0 2]
 [0 3]
 [0 4]
 [0 5]
 [0 6]
 [0 7]
 [0 8]
 [0 9]
 [1 0]
 [1 1]
 [1 2]
 [1 3]
 [1 4]
 [1 5]
 [1 6]
 [1 7]
 [1 8]
 [1 9])

(let [a (atom {:a {:b 1}})] (reset! a 2))

2

(defn arr=2 [a b] (= (seq a) (seq b)))

#'user/arr=2

(defn test-fxn [a] (println (str a "some other data")))

#'user/test-fxn

(defn poser [a coll] (mapcat vector coll (repeat a)))

#'user/poser

(doseq [a [0 1 2]]
  :when
  even?
  (println a))

nil

"0\n1\n2\n"

(macroexpand '(let [{:keys [a b]} somemap] [a b]))

(let [{:keys [a b]} somemap] [a b])

((fn [[a b]] (prn "A: " a)) [1 2])

nil

"\"A: \" 1\n"

(defn me [& a] (if (seq a) true false))

#'user/me

(defmulti jean (fn [a b] [(type a) (type b)]))

#'user/jean

(let [a "5" b 10] (Integer/valueOf ^Integer a b))

5

(defn swap [f] (fn [a b] (f b a)))

#'user/swap

(defn xor [a b] (not= (boolean a) (boolean b)))

#'user/xor

(let [a (atom 0)] (defn inc-counter [] (swap! a inc)))

#'user/inc-counter

(defn xor2 [a b] (not= (boolean a) (boolean b)))

#'user/xor2

(let [[a b :as c] nil] [a b c])

[nil nil nil]

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

nil

"2"

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

3

(defn foo [& {:keys [a b]}] (+ a b))

#'user/foo

(let [[a & rest] [1 2 3 4]] a)

1

((fn clojure.core/fn [a] (if a (clojure.core/fn nil) 2)) 1)

2

(((fn [a] (fn [b] (+ a b))) 5) 6)

11