(reductions conj [] '(a b c d))

([] [a] [a b] [a b c] [a b c d])

(defprotocol Hello
  (foo [a])
  (foo [x y]))

{:methods #{#object
             [clojure.lang.MultiFn 0x71163bab "clojure.lang.MultiFn@71163bab"]},
 :name user/Hello,
 :ns #object [sci.impl.vars.SciNamespace 0x37a47b18 "user"],
 :sigs {:foo {:arglists ([x y]), :doc nil, :name foo}}}

(clojure.walk/macroexpand-all '(->> a (->> b c)))

(a (c b))

(get '[a b c d] 3)

d

(let [a 2 s 'a] (resolve s))

nil

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

#'user/a

(declare a b c d e ...)

#'user/...

(do (defrecord R1 [a b])
    (identity R1))

user/R1

((fn [a & r] (class r)) (range))

nil

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

(d (c (b a)))

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

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

(macroexpand-1 (read-string "(./join a bc)"))

(./join a bc)

(macroexpand '(when x a b c))

(if x (do a b c))

(into (sorted-map) '([a b] [c d]))

{a b, c d}

(reduce (fn [a x] (throw "explode")) 0 [])

0

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

nil

(list* 'fn nil '[[] (a b c)])

(fn nil [] (a b c))

(nth '(a b c d) 2)

c

(defn a [future-mapping] #(+ % 1))

#'user/a

(type (nth '(a v c) 0))

clojure.lang.Symbol

(re-matches #"[a[b]c]" "b")

"b"

(list? (list (set '(a b c))))

true

(defmulti second-arg-inc'd-in-words (fn [a b] (inc b)))

#'user/second-arg-inc'd-in-words

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

3

(if-let [a true
         b false]
  :then
  :else)

:then

(if-let [a nil
         b nil]
  :then
  :else)

:else

(str (class ((fn a [] ((fn b [] b))))))

"class sci.impl.fns$fun$arity_0__26683"

(let [a 1] (eval `(inc ~a)))

2

(symbol "complex phrase as a symbol name")

complex

(let [a '(1 1)] `(~a))

((1 1))

(def x `[a 42 b :some])

#'user/x

(get 3 '(a b c d))

nil

(reduce concat '(([a b]) ([c d])))

([a b] [c d])

(not (not (not '(a b c))))

false

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

3

(binding [*ns* (create-ns 'bla)] (def a 1))

#'user/a

(map (fn [a] 0) (take 24 (range)))

(0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0)

(let [a 2 s 'a] (prn s))

nil

"a\n"

(macroexpand '(let [a b] (f x)))

(let [a b] (f x))

(let [q '((a b) ())] (first q))

(a b)

(let [a 1] `(n ~a d))

(user/n 1 user/d)

(let [[a & b] [1]] (class b))

nil

(re-find #"the" "hey, there's a regex here!")

"the"

(macroexpand-1 '(-> x (a b c)))

(a x b c)

(clojure.walk/macroexpand-all '(-> a (->> b c)))

(c (b a))

(defn x [a b c] (println "foo"))

#'user/x

(-> *
    #(%)
    (->> (def a)))

#'user/a

(let
  [a [[36 116 105 109
       [101 114 32 49
        [54 58 48 58
         [48 32 44 40
          [108 101 116 32
           [91 119 104 97
            [116 39 115 32 [39 116 104 105 [115 63 32 97 32]]]]]]]]]
      "] (println (apply str (apply str (map char (flatten (a 0)))) a (a 1))))"]]
  (println (apply str (apply str (map char (flatten (a 0)))) a (a 1))))

nil

"$timer 16:0:0 ,(let [what's 'this? a [[36 116 105 109 [101 114 32 49 [54 58 48 58 [48 32 44 40 [108 101 116 32 [91 119 104 97 [116 39 115 32 [39 116 104 105 [115 63 32 97 32]]]]]]]]] \"] (println (apply str (apply str (map char (flatten (a 0)))) a (a 1))))\"]] (println (apply str (apply str (map char (flatten (a 0)))) a (a 1))))\n"

((fn [& {:keys [a b c], :or {c 42}}] [a b c]) :a 1 :b 2)

[1 2 42]

(let [as [1 2 3] bs [:c :d :e]] (for [a as b bs] [a b]))

([1 :c] [1 :d] [1 :e] [2 :c] [2 :d] [2 :e] [3 :c] [3 :d] [3 :e])