(select-keys '[a b c d] [1 2])

{1 b, 2 c}

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

((a b) (b c) (c d))

(println "lazybot from within a line of chat.")

nil

"lazybot from within a line of chat.\n"

(let [[a b & c] (range 3 9)])

nil

(clojure.string/replace
  (print-str '((E
                (C)
                (F F)
                (A A)
                H
                ((G) B)
                ((E G (I (I I A)) H (B) C (D (H))) (F C C)))))
  #" "
  "")

"((E(C)(FF)(AA)H((G)B)((EG(I(IIA))H(B)C(D(H)))(FCC))))"

(defprotocol P
  (a
    ...)
  (b
    ...)
  (c
    ...))

{:ns #object[sci.impl.vars.SciNamespace 0x37a47b18 "user"], :name user/P, :methods #{#object[clojure.lang.MultiFn 0x3c68ee4a "clojure.lang.MultiFn@3c68ee4a"] #object[clojure.lang.MultiFn 0x32af07b7 "clojure.lang.MultiFn@32af07b7"] #object[clojure.lang.MultiFn 0x3690853a "clojure.lang.MultiFn@3690853a"]}, :sigs {:a {:name a, :arglists (...), :doc nil}, :b {:name b, :arglists (...), :doc nil}, :c {:...

((fn [{:keys [a b], :as k}] k) 1)

1

(re-seq #"[a-z]+" "this is a test")

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

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

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

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

#'user/tester2

(do (def ^{:type :a} a 5) nil)

nil

(for [x '(a b c)] [:record val])

([:record #object [clojure.core$val 0xacd3494 "clojure.core$val@acd3494"]]
 [:record #object [clojure.core$val 0xacd3494 "clojure.core$val@acd3494"]]
 [:record #object [clojure.core$val 0xacd3494 "clojure.core$val@acd3494"]])

(defmacro ap [f & a] `(~f ~@a))

#'user/ap

(into {} '([a b] [c d] [e f]))

{a b, c d, e f}

(defmacro m [] (let [a 1] `(list ~a)))

#'user/m

((fn [a b & c]) 1 2 nil)

nil

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

3

(let [a [1 2]] `[3 ~@a 4])

[3 1 2 4]

(read-string "(fn foo [a b c])")

(fn foo [a b c])

(count "(fn[&[a b]]b)")

13

(concat '(a b c) (when false ['x]))

(a b c)

(re-find #"\*\S+?\*" "This is a *test* of regex")

"*test*"

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

#'user/foo

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

()

(map #(list 'quote %) '(a b))

((quote a) (quote b))

(some (partial = 'c) '(a b c))

true

(def a (fn foobar [x] (* x x)))

#'user/a

(meta (read-string "(def ^:clj a 1)"))

{:column 1, :line 1}

(println "syms: " '(a b c d))

nil

"syms:  (a b c d)\n"

(re-find #"(a)(s)(d)(f)" "asdf")

["asdf" "a" "s" "d" "f"]

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

nil

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

(a 1 b 2 c 3)

(let [a (range 3)] `(:foo ~a :bar))

(:foo (0 1 2) :bar)

(apply (fn [a & b] (second b)) (range))

2

(do (def a (filter odd? (range 100))) nil)

nil

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

(a b (clojure.core/unquote c) d)

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

((a 1) (b 2))

(map (fn [a] (* 2)) [1 2 3])

(2 2 2)

((fn [a b & c] c) 1 2)

nil

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

(a b c d e f)

(macroexpand-1 '(->> A (F E R T)))

(F E R T A)

(let* [vec__109 [1] a (clojure.core/nth vec__109 0 nil)])

nil

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

4

(into {} (map-indexed vector '(a b c d)))

{0 a, 1 b, 2 c, 3 d}

(def ^{:doc "I am a doc-string"} somevar)

#'user/somevar

(defn foo [a b] (eval (+ b 10)))

#'user/foo

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

(a (b (c d)) e)

(read-string "(time `(a ~b ~@c))")

(time
  (clojure.core/sequence
    (clojure.core/seq (clojure.core/concat (clojure.core/list (quote user/a))
                                           (clojure.core/list b)
                                           c))))

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

(quote (quote (quote (b a))))

(map '[a b c d] [1 2])

(b c)