(reduce conj [:a :b :c] (range 10))

[:a :b :c 0 1 2 3 4 5 6 7 8 9]

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

{:three 3, {:one 1} {:two 2}}

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

#{#{5} 1 2 3}

(reduce conj {} (seq {:a 1, :b 2}))

{:a 1, :b 2}

(defn foo [] (reduce conj '() '("hello" "world")))

#'user/foo

(conj {} nil [:x 1] {:y 2, :z 3})

{:x 1, :y 2, :z 3}

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

[#object
  [clojure.lang.PersistentList$Primordial 0x496348fc
   "clojure.lang.PersistentList$Primordial@496348fc"] 1 2 3 4 5 6]

(conj (map inc [2 3 4 5]) 7)

(7 3 4 5 6)

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

#{1 2 3}

(do (conj (map print (range 10)) 0) nil)

nil

"0123456789"

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

clojure.lang.Cons

(class (reduce conj () [1 2 3 4 5]))

clojure.lang.PersistentList

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

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

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

(5 4 3 2 1)

(apply conj [] '(1 2 3 4 5))

[1 2 3 4 5]

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

[1 2 3 4 [5 6 7]]

(update-in {:t {:a [4]}} [:t :a] conj 5)

{:t {:a [4 5]}}

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

{:a [1 2 3 42]}

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

#'user/blah!

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

[1 2 3 4 5]

(vec (conj (seq (vector 1 2 3)) 4))

[4 1 2 3]

(conj (sorted-map :quux 3) {:foo 1, :bar 2})

{:bar 2, :foo 1, :quux 3}

(meta #^{:my :meta} (conj [1 2] 3))

nil

(map #(conj % :bar) ['(:foo) [:foo]])

((:bar :foo) [:foo :bar])

(meta (with-meta (conj [1 2] 3) {:my :meta}))

{:my :meta}

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

[1 2 3 4 5 6]

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

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

(= '(:a :b) (conj '(:a) :b))

false

(let [v []] (let [n 3] (conj v 3)))

[3]

(= [1 2 3] (conj [] 1 2 3))

true

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

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

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

[1 2 3 4 5 6]

(conj (array-map :a 1 :b 2) [:c 3])

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

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

{1 2, 3 4, 5 6}

(conj {:a 1} (seq {:b 2, :a 3}))

{:a 3, :b 2}

(update {:contacts ["abc"]} :contacts #(conj % "def"))

{:contacts ["abc" "def"]}

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

(5 1 2 3)

(map conj [[1 2] [3 4]] ["a" "b"])

([1 2 "a"] [3 4 "b"])

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

{:myvector [1 2 3 4]}

(update-in {"a" {"d" ["1"]}} ["a" "d"] conj "2")

{"a" {"d" ["1" "2"]}}

(take 5 (iterate #(conj % (rand-int 10)) []))

([] [4] [4 1] [4 1 2] [4 1 2 9])

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

{1 2, 3 4, 5 6}

(swap! (atom {:foo [:bar]}) update-in [:foo] conj :baz)

{:foo [:bar :baz]}

(apply conj () '(1 2 3 4 5))

(5 4 3 2 1)

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

[a b c d]

(reductions #(conj %1 %2) [] [1 2 3])

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

(let [xs (range 5)] (reduce conj xs xs))

(4 3 2 1 0 0 1 2 3 4)

(let [a ()] [(class (conj a 1)) (class a)])

[clojure.lang.PersistentList clojure.lang.PersistentList$EmptyList]

(apply conj [[:a :b :c] :d :e :f])

[:a :b :c :d :e :f]

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

#{1 2 3 4 5}