(defn first2 [a b & c] [a b])

#'user/first2

(when-let [{:keys [a b c]} {}] [a b c])

[nil nil nil]

(let [a 1 b 2] '{a b})

{a b}

(-> [1 2]
    ((fn [[a b]] [b a])))

[2 1]

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

3

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

(0 0 1 0 1 2)

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

2

(if-let [a 2] (if-let [b 2] [a b]))

[2 2]

(defmulti concat_fruit (fn [a & args] (:kind a)))

#'user/concat_fruit

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

[2 0 1]

((fn [& {:as a}] (println a)) :key "value")

nil

"{:key value}\n"

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

[nil nil nil]

(defn test-palindromic [c] (for [a (str c)] a))

#'user/test-palindromic

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

(a b)

(let [a 42 b 43] (or a b))

42

(let [{a 2, b 3} "foobar"] [a b])

[\o \b]

(def x (with-meta (fn [a] a) {:doc "test"}))

#'user/x

(macroexpand-1 '(let [{a :a} {:a 5}] a))

(let [{a :a} {:a 5}] a)

(let [a + + 2] (a + 4))

6

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

3

((fn [a] {"asdfasd" a}) {:account 1, :type :foo})

{"asdfasd" {:account 1, :type :foo}}

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

2

(defn | [a b c] (b c a))

#'user/|

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

(0 0 1)

(def foo (clojure.core/fn ([a b] (+ a b))))

#'user/foo

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

[1 nil nil]

(meta (with-meta (fn [a] (inc a)) {:hello :world}))

{:hello :world}

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

2

(let [myfun (fn [a] (inc a))] (myfun 42))

43

(reduce (fn [a b] (inc a)) 0 '())

0

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

1

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

1

(clojure.walk/prewalk-replace '{a b} '(c (d a)))

(c (d b))

(let [[a] [1 2 3 4 5]] a)

1

(let [[a :as x b] [1 2]] a)

1

(first (for [a (range)] (do (pr '.) a)))

0

"."

(let [a (atom 5)]
  (swap! a inc)
  @a)

6

(defmacro infix [[a op b]] (op a b))

#'user/infix

(do (for [a (range 10)] (println a)) nil)

nil

(defn optional [a b? c] (println a c))

#'user/optional

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

1

(let [{{a :b} :a} {:a {:b 'c}}] a)

c

(let [a (delay (+ 1 2))] (force a))

3

(let [a (atom true)]
  (println a)
  (println @a))

nil

"#object[clojure.lang.Atom 0x56d66b93 {:status :ready, :val true}]\ntrue\n"

((fn [a] (= (a :name) :bah)) {:name :bah})

true

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

nil

"1 2"

(defn iwc [a b] (list '+ a b))

#'user/iwc

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

2

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

3

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

:hi