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

[1 2 nil]

(loop [a (range 10) b (range 10)] [a b])

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

(let [a (double-array '(1.2 2.3))] (aget a 1))

2.3

(let [{[a b] :foo} {:foo [1 2]}] [a b])

[1 2]

(let [a "s"]
  (case (class a)
    java.lang.String :found
    :not-found))

:not-found

((fn ([a] a) ([& more] (reverse more))) (range 10))

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

(->> 3
     (- a)
     (/ 4)
     (let [a 7]))

1

((fn f [& {:keys [a]}] (inc a)) :a 1)

2

(let [a (atom '(1))] (swap! a conj 0))

(0 1)

(defn foo [object a b] (.baz object a b))

#'user/foo

((fn [[a & b]] a) '(1 2 3))

1

(for [a [:a :b] b [1 2]] [a b])

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

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

[:bar :foo]

(macroexpand '(doto x ("for" [a b] (c a))))

(clojure.core/let [G__3087293 x]
  ("for" G__3087293 [a b] (c a))
  G__3087293)

(let [a {:one 1, :two 2}] (a :one :two))

1

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

2

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

#'user/partial1

((fn fn [a] (if a (fn nil) 2)) 1)

2

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

#'user/foo

(let [a (map prn (range 5))]
  (dorun a)
  :hi)

:hi

"0\n1\n2\n3\n4\n"

(let [a (atom true)] (defn spinner [] (swap! a not)))

#'user/spinner

(let [a {:abc-one 1, :abc-two 2}] (a (keyword "abc-one")))

1

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

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

((fn [^objects a] (aget a 0)) (into-array Object [7]))

7

(for [a (range 2) b (range 2)] [a b])

([0 0] [0 1] [1 0] [1 1])

(let [a '(typereff nil)] (= (first a) 'typereff))

true

(for [a [5] b [1 11]] (list a b))

((5 1) (5 11))

(macroexpand '(doto x (for [a b] (c a))))

(clojure.core/let [G__1368432 x]
  (for G__1368432
       [a b]
       (c a))
  G__1368432)

(let [[& {a :a}] {:foo 10, :bar 20}] a)

nil

(defmulti pushable? (fn [a b] [(:Pile a) (:Pile b)]))

#'user/pushable?

(#(let [a (last %&)] (a)) #(println 1))

nil

"1\n"

((fn [a b] [a b]) (range 10) (range 10))

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

((fn [[a & b]] {:a a, :b b}) "hello")

{:a \h, :b (\e \l \l \o)}

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

#'user/f

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

([2 1] [4 3])

(let [a (int-array '(1 2 3))] (alength a))

3

(defn duration-ms [a b] (- (.getMillis b) (.getMillis a)))

#'user/duration-ms

(let [a :x]
  (case a
    :z 1
    :x 2))

2

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

1

(doseq [[a b] ["a" "b"]] (println (str a b)))

nil

"a\nb\n"

(let [a 1] (map class [a 'a :a "a"]))

(java.lang.Long clojure.lang.Symbol clojure.lang.Keyword java.lang.String)

(defn myf [a & {:as options}] (println a options))

#'user/myf

(let [q (fn [& a] (coll? a))] (q "foo"))

true

(let [{a :a, :as m} 5] (println a m))

nil

"nil 5\n"

(apply (fn [a b] (+ a b)) [10 20])

30

(defn f [x & a] (apply x 2 a))

#'user/f

(defn hinted (^String []) (^Integer [a]) (^java.util.List [a & args]))

#'user/hinted

(defn mult [#^Integer a #^Integer b] (* a b))

#'user/mult

((fn [& {:keys [a]}] (+ a 5)) :a 10)

15

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

3