(let [x #{}]
  (conj x "foo")
  x)

#{}

(conj {:a :b} {:c :d, :e :f})

{:a :b, :c :d, :e :f}

(reduce conj #{} [1 2 3 4])

#{1 2 3 4}

(type (rest (conj (seq [1 2]) 3)))

clojure.lang.PersistentVector$ChunkedSeq

(apply conj {} (seq {1 2, 3 4}))

{1 2, 3 4}

(conj [{:one 1} {:two 2}] {:three 3})

[{:one 1} {:two 2} {:three 3}]

(conj (take-last 2 [1 2 3]) 0)

(0 2 3)

(update-in {:wtf {:omg []}} [:wtf :omg] conj "LOL")

{:wtf {:omg ["LOL"]}}

(conj {:a 10, :b 20} {:c 30})

{:a 10, :b 20, :c 30}

(merge-with conj {:a ()} {:a 1, :b 2})

{:a (1), :b 2}

(conj [1 2 3] [4 5 6])

[1 2 3 [4 5 6]]

(conj #{:a :b :c :d} :e)

#{:a :b :c :d :e}

(reduce conj '() [1 2 3 4])

(4 3 2 1)

(conj {1 2} {3 4, 5 6})

{1 2, 3 4, 5 6}

(conj '(:a :b :c :d) :e)

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

(conj {:a 5, :b 6} [:c 7])

{:a 5, :b 6, :c 7}

(-> []
    (conj (when (= 1 2) 12)))

[nil]

(conj (map identity [1 2 3]) 2)

(2 1 2 3)

(transduce (map inc) conj [] [0 1 2])

[1 2 3]

((partial reduce conj '()) [1 2 3])

(3 2 1)

(apply conj [[1 2 3] :b 'a])

[1 2 3 :b a]

(conj {} (find {:a 1, :b "BEEES"} :a))

{:a 1}

(letfn [(p [x] (zero? (mod x 3)))]
  (apply conj
    (reduce (fn [[coll sub] e]
              (if (p e) [(conj coll sub) []] [coll (conj sub e)]))
      [[] []]
      (range 10))))

[[] [1 2] [4 5] [7 8] []]

(first (reduce (fn [[acc prev] e] [(conj acc [e prev]) (conj prev e)])
         [[] []]
         [:a :b :c :d]))

[[:a []] [:b [:a]] [:c [:a :b]] [:d [:a :b :c]]]

(let [a {:a []}
      c [{:a 2} {:a 3}]]
  (reduce (partial merge-with conj) {:a []} (conj c a)))

{:a [2 3 []]}

(first (reduce (fn [[acc prev] e] [(conj acc (vector e prev)) (conj prev e)])
         [[] []]
         [:a :b :c :d]))

[[:a []] [:b [:a]] [:c [:a :b]] [:d [:a :b :c]]]

(conj [1 2 3 4 5] 6)

[1 2 3 4 5 6]

(defmacro blah! [x] (swap! x conj "yo"))

#'user/blah!

((partial reduce conj) [1 2] (range 5))

[1 2 0 1 2 3 4]

(conj {:a 1, :c 3} [:b 2])

{:a 1, :b 2, :c 3}

(conj {:foo :bar} {:a :b, :c :d})

{:a :b, :c :d, :foo :bar}

(conj (concat [1 2 3] [4]) 5)

(5 1 2 3 4)

(update {:name "john", :friends []} :friends conj "bob")

{:friends ["bob"], :name "john"}

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

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

(mapv #(reduce conj % (range 10)) [() []])

[(9 8 7 6 5 4 3 2 1 0) [0 1 2 3 4 5 6 7 8 9]]

(conj '(1 2 3) {:a 1})

({:a 1} 1 2 3)

(conj #{5} #{1 2 3})

#{#{1 2 3} 5}

(update-in {:foo [1 2]} [:foo] conj 3)

{:foo [1 2 3]}

(#(apply str (reduce conj () %)) "pey")

"yep"

(transduce (partition-all 2) conj [] [1 2 3])

[[1 2] [3]]

(update-in (vec (repeat 10 [])) [3] conj :a)

[[] [] [] [:a] [] [] [] [] [] []]

(reduce conj #{} [1 2 3 2])

#{1 2 3}

(conj {:a 1} (when true {:b 2}))

{:a 1, :b 2}

(type (conj (vector 1 2 3) 4))

clojure.lang.PersistentVector

((juxt pop identity peek) (conj [0] 1))

[[0] [0 1] 1]

(update-in {:a [0]} [:a] (fnil conj []) 1)

{:a [0 1]}

(conj {:a :b} (when true {:c :d}))

{:a :b, :c :d}

(apply update-in {} [[:deletes] conj 13 12 1])

{:deletes (1 12 13)}

(conj {:a :b} (when false {:c :d}))

{:a :b}

(apply println 1 (conj [2 3] 4))

nil

"1 2 3 4\n"