(first (remove '#{a b c} '[b c d]))

d

(clojure.string/replace "there's a hole in the bucket, elijah." #"\PL|\PN" "")

""

(binding [*read-eval* true] '(+ a #=(* 3 5)))

(+ a 15)

(def a (seque 5 (repeatedly #(or (println ".") 5))))

#'user/a

(let [[n [d]] '(a (b))] {:n n, :d d})

{:d b, :n a}

(map list '[a b c] '[d e f])

((a d) (b e) (c f))

(let [a (atom {1 {:ugh :yay}})]
  (-> 1
      (@a)
      :ugh))

:yay

(defmacro mm [a & body] (let [ea ~a] `(...)))

#'user/mm

(-> '(and a b c d)
    macroexpand-1
    macroexpand-1
    macroexpand-1)

(and a b c d)

(partition 2 2 [nil] '[a 1 b 2 c])

((a 1) (b 2) (c nil))

(partition 2 (interleave (iterate inc 0) '(a b c)))

((0 a) (1 b) (2 c))

(str (type nil) " is not a valid option, buster")

" is not a valid option, buster"

(defmacro a [& b] `(let [b# (vec ~b)] b#))

#'user/a

(partition 2 (interleave [1 2 3] '[a b c]))

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

(try (Integer/parseInt "not a number") (catch Exception e (class e)))

java.lang.NumberFormatException

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

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

(def data '[[a * b] + [c * d]])

#'user/data

(defmacro def-field [a b] {:fields a, :builder `(quote ~b)})

#'user/def-field

(let [[a & b] (iterate inc 0)] (take 5 b))

(1 2 3 4 5)

(vec (map vector '[a b c] [1 2 3]))

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

(take 2 (map inc '(3 9 a b c)))

(4 10)

(defn my-template [x y] `[a b c ~x ~@y])

#'user/my-template

(defn ^double f [^double a ^double b] (+ a b))

#'user/f

(split-at 2 (interleave [1 2 3] '[a b c]))

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

(binding [*print-meta* true] (prn (macroexpand '(-> a #^Integer (b)))))

nil

"^{:tag Integer, :line 1, :column 55} (b a)\n"

(defmacro w [a] `(mdo a# ~'<- ~a (return a#)))

#'user/w

(apply str (re-seq #"[A-Z]" "This Is A Test"))

"TIAT"

(macroexpand '(defmacro a [c b] `(+ ~c ~b)))

(defmacro a
  [c b]
  (clojure.core/sequence
    (clojure.core/seq
      (clojure.core/concat (clojure.core/list (quote clojure.core/+))
                           (clojure.core/list c)
                           (clojure.core/list b)))))

(loop [x nil z (nil? x) [a b] x] nil)

nil

(meta (second '(def ^{:arglists ([a b c])} foo)))

{:arglists ([a b c])}

(map '[a b c d e] [0 2 4])

(a c e)

(->> ["apple" "pear" "banana"]
     (interpose " a ")
     (apply str))

"apple a pear a banana"

(reduce #(cons %2 %1) () '(a b c d))

(d c b a)

(let [xs [1 2 3]] `(foo a ~@xs b))

(user/foo user/a 1 2 3 user/b)

(sort '[[3 a] [2 b] [4 c] [1 d]])

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

(re-seq #"[sb]a[gd]" "Sad bag sag bad?")

("bag" "sag" "bad")

(defn add [m a b] (mod (+ a b) m))

#'user/add

(let [L (with-meta '(a b) {:foo :bar})] (next L))

(b)

(apply max-key first '([1 a] [2 b] [3 c]))

[3 c]

(map-indexed #(list % %2) '(a b c d))

((0 a) (1 b) (2 c) (3 d))

(map vec (partition 2 '(a 1 b 2 c)))

([a 1] [b 2])

(def a (atom {:hi "there", :list [1 2 3 4]}))

#'user/a

(defmacro dot-apply* [t m a] `(. ~t ~m ~@a))

#'user/dot-apply*

(into [] '({:a a, :b b} {:c c, :d d}))

[{:a a, :b b} {:c c, :d d}]

(macroexpand '(doto (a b c) (d e) (f g)))

(clojure.core/let [G__50497 (a b c)]
  (d G__50497 e)
  (f G__50497 g)
  G__50497)

(defn f ^double [^double a ^double b] (+ a b))

#'user/f

(defn foo [& {:keys [a b], :or {b @a}}] b)

#'user/foo

(macroexpand-1 '(-> x (a b) c (d e f)))

(d (c (a x b)) e f)

(conj (re-seq #"[^ ]+" "this is a test") "hello")

("hello" "this" "is" "a" "test")

(defmacro f [] `(do (def a 1) (def b 2)))

#'user/f