((fn [coll]
   (->> coll
        (partition 2 1)
        (map (fn [[[a x] [b y]]] [[a b] (- y x)]))))
  [["a" 1] ["b" 5] ["c" 7]])

([["a" "b"] 4] [["b" "c"] 2])

(defn foo
  [a & rst]
  (let [[b c & d] rst args [b c]] {:a a, :b b, :c c, :args args, :rst rst}))

#'user/foo

(let [{:keys #{a b c d e f g h i}} {:a 1, :b 2, :c 3, :d 4}] [a b c d])

[1 2 3 4]

(println "is for code evaluation in the middle of a message")

nil

"is for code evaluation in the middle of a message\n"

(some number? (apply concat (apply concat '[[[a b] [c]] [[d]]])))

nil

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

[1 2 3 4]

(:else {:else "is kind of a function, but not like that"})

"is kind of a function, but not like that"

(let [thing-to-add '(a b c)] (into [:div {:class "test"}] thing-to-add))

[:div {:class "test"} a b c]

(let [items '[a b c]] (map list items (rest items)))

((a b) (b c))

(into {} (for [k '[a b c]] [k (str k "val")]))

{a "aval", b "bval", c "cval"}

(doseq [:let [a 1] b '(1 2 3)] (println b))

nil

"1\n2\n3\n"

((fn [{:keys [:a :b]}] (+ a b)) {:a 40, :b 2})

42

(mapcat #(list (str % "=") %) '(a b c))

("a=" a "b=" b "c=" c)

(defmacro b [y x & z] `(a ~y ~x ~@z))

#'user/b

(let [x [1 2 3]] `[a b ~@x c d])

[user/a user/b 1 2 3 user/c user/d]

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

nil

(apply (fn [a b c d e & more] c) (range))

2

(str "this method of evaluation at the end of a message")

"this method of evaluation at the end of a message"

(for [[a b c] [[1 2 3] [4 5 6]]] b)

(2 5)

((fn ([z1 z2 & zs] :zs) ([a b] :ab)) 1 2)

:ab

(some #{'a 'b} '(1 2 3 4 a c))

a

(symbol "string whose characters do not make up a valid symbol")

string

({:akey "This is a value.", :anotherkey "This is another value."} :akey)

"This is a value."

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

nil

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

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

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

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

(into {} (map #(vector (keyword %) %) '(a b c)))

{:a a, :b b, :c c}

(read-string (with-out-str (pr '(a b :a :b [1 2 3]))))

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

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

{:a 1, :b 2}

(defn a [x] (if (> x 0) ((println "Hello") (println "World"))))

#'user/a

(defn myf ([a] (myf 1 +)) ([b func] (func 1 b)))

#'user/myf

(some number? (apply concat (apply concat '[[[a b] [9]] [[d]]])))

true

(for [x '[a b] y '[c d]] [x y])

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

(map #(let [a %]
        into
        {}
        [[1 2]])
  [:a :b :c])

([[1 2]] [[1 2]] [[1 2]])

(let [form '(a b c)] `(insert stuff like ~@form))

(user/insert user/stuff user/like a b c)

(def a [[1 2 3] [1 2 3] [1 2 3]])

#'user/a

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

7

(into (sorted-set-by (fn [a b] (dec (rand-int 3)))) [0 1 2])

#{0 1 2}

(macroexpand-1 '(doseq [a [] b [] c [] d [] e [] f [] g [] h []]))

(loop [seq_3412456 (clojure.core/seq []) chunk_3412457 nil count_3412458 0 i_3412459 0] (if (clojure.core/< i_3412459 count_3412458) (clojure.core/let [a (clojure.core/nth chunk_3412457 i_3412459)] (loop [seq_3412968 (clojure.core/seq []) chunk_3412969 nil count_3412970 0 i_3412971 0] (if (clojure.core/< i_3412971 count_3412970) (clojure.core/let [b (clojure.core/nth chunk_3412969 i_3412971)] (loo...

(defn ^{:static true, :tag Integer} -onlineLink [^Integer a ^String b])

#'user/-onlineLink

(let [[_ _ :as first-two] '(a b c d)] first-two)

(a b c d)

(do (prn (str *ns*)) (binding [*ns* (create-ns 'foo)] (def a 1)))

#'user/a

"\"user\"\n"

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

#'user/def-field

((fn [{:keys [a b], :as opts}] (contains? opts :c)) {:a 2})

false

(seq (.split "This is a test message FOR sure!" " "))

("This" "is" "a" "test" "message" "FOR" "sure!")

((fn [& colls] (apply merge colls)) '{:option1 a, :option2 b})

{:option1 a, :option2 b}

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

#'user/a

(reduce (partial list '.) '(a b (c c2 c3) d))

(. (. (. a b) (c c2 c3)) d)

(map #(let [a %]
        into
        {}
        [[1 2]])
  [:a :b :c])

([[1 2]] [[1 2]] [[1 2]])

(map (juxt first second) `[[a 1] [b 2] [c 3]])

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