(macroexpand '(clojure.core/let [[a b] p__1022] (+ a b)))

(clojure.core/let [[a b] p__1022] (+ a b))

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

([1 1])

(clojure.set/subset? (set '(a)) (set '(a b c)))

true

(let [[a b c] (clojure.string/split "d,a,b,c" #",")] [a b])

["d" "a"]

(defmacro tester [a] `(inc ~(* a 2)))

#'user/tester

(def dumb "force a cognitive load on a programmer")

#'user/dumb

(->> (+ a 5)
     (- 20)
     (let [a 9]))

6

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

[3 nil]

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

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

(reduce (fn [a v] (if (> 5 v) (reduced a) (conj a v))) #{} (range))

#{}

(defn fibs ([] (fibs 0 1)) ([a b] (lazy-seq (cons a (fibs b (+ a b))))))

#'user/fibs

(let [a 1 b 2 _ (println a b) c 3] (+ a b c))

6

"1 2\n"

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

[3 4]

(let [a (byte-array (map byte [1 2 3 4 5]))]
  (println (into [] a))
  (aset-byte a 1 (byte 42))
  (println (into [] a)))

nil

"[1 2 3 4 5]\n[1 42 3 4 5]\n"

(let [f (fn [a b] (if (vector? a) (conj a b) (conj [a] b)))]
  (merge-with f {1 "a"} {1 "b"} {2 "c"}))

{1 ["a" "b"], 2 "c"}

(let [a (zipmap (range 100) (range 100))
      b (assoc a :c 1)
      c (dissoc b :c)]
  [(= a c) (identical? a c)])

[true false]

((fn [l & a] (if l (recur (next l) (+ (if a a 0) 1)) a)) '(1 2 3 3 1))

5

(let [a (atom (range 5))]
  (str (first (swap! a rest)) " " (first (swap! a rest))))

"1 2"

(let [{:keys [a b c], :or {a 0, b 1}, :as point} {}] [[a b c] point])

[[0 1 nil] {}]

((juxt (fn [& {:keys [a b], :or {a 10, b 20}, :as more}] [a b more])
       (fn [& {:keys [a b], :or [a 10 b 20], :as more}] [a b more]))
  :a
  10)

[[10 20 {:a 10}] [10 nil {:a 10}]]

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

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

(let [a "yep"
      b ""]
  (cond-> {}
    (seq a) (assoc :a a)
    (seq b) (assoc :b b)))

{:a "yep"}

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

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

(for [a [1 2 3] :when (== a 2) b [7 8 9]] [a b])

([2 7] [2 8] [2 9])

(defn fib-seq [] ((fn rfib [a b] (cons a (lazy-seq (rfib b (+ a b))))) 1 2))

#'user/fib-seq

(let [a (object-array 32)
      v (vec a)]
  (aset a 0 v)
  (= v (v 0)))

true

(defmacro bar [a] `(defn foo (let [tail []] (if (even? a) (cons a tail) tail))))

#'user/bar

(defn left-join [as bs pred] (for [a as] [a (first (filter #(pred a %) bs))]))

#'user/left-join

(defn mm
  [a b]
  (fn [x]
    (-> x
        (min (max a b))
        (max (min a b)))))

#'user/mm

(let [a (atom 3)
      b (atom 4)
      s #{a b}]
  (swap! a inc)
  (count s))

2

(macroexpand-1 '((fn rfib [a b] (cons a (lazy-seq (rfib b (+ a b))))) 0 1))

((fn rfib [a b] (cons a (lazy-seq (rfib b (+ a b))))) 0 1)

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

[1 2 3]

(defn new-counter [] (with-local-vars [a 0] (fn [] (var-set a (inc @a)))))

#'user/new-counter

(let [a (atom 1)] (swap! a cons '(2 3)))

(1 2 3)

(macroexpand `(doseq [a [1 2]]
                (prn a)
                (prn "blah")))

(loop [seq_985474 (clojure.core/seq [1 2]) chunk_985475 nil count_985476 0 i_985477 0] (if (clojure.core/< i_985477 count_985476) (clojure.core/let [user/a (clojure.core/nth chunk_985475 i_985477)] (do (clojure.core/prn user/a) (clojure.core/prn "blah")) (recur seq_985474 chunk_985475 count_985476 (clojure.core/unchecked-inc i_985477))) (clojure.core/let [seq_985474 (clojure.core/seq seq_985474)] ...

((fn [[z a]] (+ z a 1)) '(5 6))

12

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

#'user/new-counter

(defn mixer [a b] (reduce into [] (map vector a b)))

#'user/mixer

(defn #^{:tag Integer} foo [a b] (+ a b))

#'user/foo

(defn f [[a b c]] {(keyword a) {(keyword b) c}})

#'user/f

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

([1 1] [2 2])

(defn intersection [a b] (filter #(contains? a %) b))

#'user/intersection

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

[2 1]

(defmulti count-cat (fn [c a v] [(:category c) (:action a)]))

#'user/count-cat

(let [a {:foo [10 20 30]}]
  (-> a
      :foo
      first))

10

(defn foo [{:keys [a b c]}] (println a b c))

#'user/foo

(let [[f & a] [* 5 3]] (apply f a))

15

((fn [f a b] (f b a)) / 1 0)

0

(defmulti can-overlap? (fn [a b] (set (:type a) (:type b))))

#'user/can-overlap?

(let [a 1] (condp = a 1 "Hey" 2 "Yo"))

"Hey"