(some #(= % 'a) '(a b c))

true

(apply compare (map (juxt :time identity) '[a b]))

-1

(macroexpand-1 '(parser/view a #(= 1 %) 'ok))

(parser/view a (fn* [%1] (= 1 %1)) (quote ok))

(map list (rest (range)) '(a b c d))

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

(let [s '#{a b c d}] (s 'c))

c

(prn (class (rest (re-seq #"(a)(s)d" "asdf"))))

nil

"clojure.lang.LazySeq\n"

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

nil

(def a (map #(doto % println) (range 10)))

#'user/a

(do (defn foo [^Long a] (meta 'a)) (foo 3))

nil

((fn [a & args] (seq? args)) 1 2 3)

true

(macroexpand-1 '(when-let [[x y] (f)] a b c))

(clojure.core/let [temp__29583__auto__ (f)]
  (clojure.core/when temp__29583__auto__
    (clojure.core/let [[x y] temp__29583__auto__]
      a
      b
      c)))

(some #(= 'a %) '(b a c))

true

(map not-empty [{} () {:a 0} [1] '(a b c)])

(nil nil {:a 0} [1] (a b c))

(partition-by #{\space \tab \newline} "this is  a       string\nwhatever")

((\t \h \i \s)
  (\space)
  (\i \s)
  (\space \space)
  (\a)
  (\space)
  (\tab)
  (\s \t \r \i \n \g)
  (\newline)
  (\w \h \a \t \e \v \e \r))

(clojure.set/difference (set '(a b)) (set '(b c)))

#{a}

(frequencies "a b c d d b a c")

{\space 7, \a 2, \b 2, \c 2, \d 2}

(def a '((+ 1 2) (+ 1 3)))

#'user/a

(some #{'a 'b} '[a x c d])

a

(let [[a :as b c :as d] (range 5)])

nil

(map (fn [val] [:record val]) '(a b c))

([:record a] [:record b] [:record c])

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

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

(reduce into [] '((1 2 3) (a b c)))

[1 2 3 a b c]

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

(and a b c d)

(defn foo ([x] x) ([a b ... z] z))

#'user/foo

(let [c 17] (quote (a b (unquote c) d)))

(a b (unquote c) d)

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

{:a 1, :b nil}

((juxt type identity) (apply list `(a b c)))

[clojure.lang.PersistentList (user/a user/b user/c)]

(if-let [[a & bs] (cons nil (range 5))] bs)

(0 1 2 3 4)

(flatten [1 2 [5 6 '(a b c)]])

(1 2 5 6 a b c)

(re-find #"\*[a-z]+\*" "this is a *test* statement")

"*test*"

(comment
  and
  go
  to
  the
  end
  and
  add
  a)

nil

(defmacro foo [& body] `(let [a 1] ~@body))

#'user/foo

(sequence cat '[[a b c] [d e f]])

(a b c d e f)

(doseq [[a b] [[1 2] [3 4]]] (println b))

nil

"2\n4\n"

(reduce concat '(((a b) (c d)) ((e f))))

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

(format "%04d then a thing here %04d" 1 10)

"0001 then a thing here 0010"

((fn [x y & {:keys [a b c], :or {a 5}, :as m}]
   (if (every? (set (keys m)) [:b :c]) [x y a b c m] "error"))
  1
  2
  :c
  3)

"error"

(apply (fn [a & b] (type b)) (range 50))

clojure.lang.LongRange

(macroexpand '(-> long (very and boring) (a story)))

(a (very long and boring) story)

(def a (map #(/ 1 %) (repeat 0)))

#'user/a

(defn a [] {:a 1, :b 2, :c (rand-int 100)})

#'user/a

(mapcat identity '[[a b [c d]] [e f]])

(a b [c d] e f)

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

"\\1"

(macroexpand-1 '(doseq [a (range 10) b (range 10)]))

(loop [seq_50818 (clojure.core/seq (range 10)) chunk_50819 nil count_50820 0 i_50821 0] (if (clojure.core/< i_50821 count_50820) (clojure.core/let [a (clojure.core/nth chunk_50819 i_50821)] (loop [seq_50826 (clojure.core/seq (range 10)) chunk_50827 nil count_50828 0 i_50829 0] (if (clojure.core/< i_50829 count_50828) (clojure.core/let [b (clojure.core/nth chunk_50827 i_50829)] (do) (recur seq_5082...

(def a #{["cat" "man"] ["man" "snake"] ["spider" "cat"]})

#'user/a

(doseq [a [] b [] c [] d [] e [] f [] g [] h []])

nil

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

2

((fn [a & [option]] (or option "default")) nil nil)

"default"

(-> 'd
    (list (map symbol '(a b c))))

(d (a b c))

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

((a b c d))