(sort-by second '([a 2] [b 3]))

([a 2] [b 3])

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

3

(def a (re-matcher #".*\[.*" "t[est"))

#'user/a

(defmacro b [a] `(baz (bar ~'~a)))

#'user/b

(def my-func (clojure.core/fn ([a b c d])))

#'user/my-func

('[a e i o u] 3)

o

(into [] (map first '((a) (b) (c))))

[a b c]

(do (defrecord Test [a])
    (:a (Test. 4)))

4

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

(1 1)

(macroexpand-1 `(fn a [] (+ 1 2)))

(clojure.core/fn user/a [] (clojure.core/+ 1 2))

(re-seq #"[\w ]" "have a nice")

("h" "a" "v" "e" " " "a" " " "n" "i" "c" "e")

(-> (a b c)
    quote
    rest
    type)

clojure.lang.PersistentList

((fn f [a b]
   (if (and (map? a) (map? b)) (merge-with f a b) (throw (Exception.))))
  {:a {:b {:c 2}}}
  {:a {:b {:z 3}, :d 2}})

{:a {:b {:c 2, :z 3}, :d 2}}

(let [a 1 b 2 c 3])

nil

(defn a [x y] (+ x y))

#'user/a

(defn abc [a b c] (prn 1))

#'user/abc

(macroexpand '(-> x ((f a b))))

((f a b) x)

(partition 2 '[a b c d])

((a b) (c d))

(some #{'a} '(b a c))

a

(apply hash-map '(a 2 b 4))

{a 2, b 4}

(read-string "{a :a b :b}")

{a :a, b :b}

(partition 2 '(a 1 b 2))

((a 1) (b 2))

(apply hash-map '(a b c d))

{a b, c d}

(def a '(1 2 3 4))

#'user/a

(clojure.string/split "this is a string" #" ")

["this" "is" "a" "string"]

(macroexpand '(let [a b] (c d)))

(let [a b] (c d))

(def a {:given-name "John", :surname "von Neumann"})

#'user/a

(clojure.string/trim "** THIS IS A HEADLINE **")

"** THIS IS A HEADLINE **"

(let [a 3] (println (+ 1 1)))

nil

"2\n"

(apply str (reverse "this is a test"))

"tset a si siht"

(let [[a :as numbers] (range 5)] numbers)

(0 1 2 3 4)

(def a [1 2 3 4 5])

#'user/a

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

(d (c (b a)))

(defn t [a & args] (class args))

#'user/t

(map first '([a b] [c d]))

(a c)

(map first '(([a b]) ([c d])))

([a b] [c d])

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

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

(take-nth 2 '[a 1 b 2])

(a b)

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

2

(defn fibo
  [x n a b]
  ((if (> x n) '() (concat '(+ a b) (fibo (+ x 1) n b (+ a b))))))

#'user/fibo

(let [a {1 1, 2 2, 3 3, 4 4, 5 5, 6 6, 7 7, 9 9}]
  [(class (conj a [8 8])) (class a)])

[clojure.lang.PersistentHashMap clojure.lang.PersistentArrayMap]

(let [a {:a 0, :b 1, :c 2}
      b {:b 3, :c :4, :d 5, :e 6}]
  (merge (select-keys a (keys b)) (select-keys b (keys a))))

{:b 3, :c :4}

(do (defn a [] 1)
    (defn b [f] (fn [] (f)))
    (def c (b a))
    (def d (b #'a))
    [[(c) (d)] (do (defn a [] 2) :-) [(c) (d)]])

[[1 1] :- [1 2]]

((fn drop1 [[x & y :as s]]
   (when (seq s) (if (= x 'a) y (lazy-seq (cons x (drop1 y))))))
  '[a b a b a])

(b a b a)

(case (symbol "a")
  a :a
  b :b)

:a

(def a [:a1 :a2 :a3 :a4 :a5])

#'user/a

(macroexpand-1 '(let [[a b] (range)] b))

(let [[a b] (range)] b)

(take 15 (cycle '(a b c)))

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

(get '(a b c d) 2)

nil

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

()