(conj [:a :b :c] "hello")

[:a :b :c "hello"]

(conj {:foo :b} {:bar :a})

{:bar :a, :foo :b}

(apply conj [1] [0 0])

[1 0 0]

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

{:a 5, :b 6}

(conj [1 2 3] 5)

[1 2 3 5]

(macroexpand '(->> [] (conj 2)))

(conj 2 [])

(conj {:foo 1} {:foo 2})

{:foo 2}

(conj [1 2 3] [nil])

[1 2 3 [nil]]

(conj #{1 2} 2)

#{1 2}

(conj [{:q 1}] {:p 0})

[{:q 1} {:p 0}]

(update-in {:k []} [:k] conj 0)

{:k [0]}

(reduce conj [] [1 2 3])

[1 2 3]

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

{1 2, 3 4}

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

{:a 1, :b 2}

(->> 10
     conj
     (-> [1]))

[1 10]

(conj '(0) 1 2)

(2 1 0)

(= (conj () 3) (list 3))

true

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

{:a 2}

(seq (apply conj [] (range 5)))

(0 1 2 3 4)

((comp seq conj) [] 1 2)

(1 2)

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

{[:a 1] [:b 2]}

(update-in {} [:foo] (fnil conj []) :baz)

{:foo [:baz]}

(= '(3 4 5) (conj '(3 4) 5) (conj [3 4] 5))

false

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

{1 2, 3 4}

(conj (lazy-seq [1 2 3]) "b")

("b" 1 2 3)

(reduce conj () '(1 2 3))

(3 2 1)

(class (conj (first {:a 1}) 2))

clojure.lang.PersistentVector

(update-in [[1 2]] [0] conj 3)

[[1 2 3]]

(merge-with conj {:abc nil} {:abc :def})

{:abc (:def)}

(reduce conj (list) (range 1 5))

(4 3 2 1)

(pop (conj [1 2 3] 4))

[1 2 3]

(conj '(1 2 3) 5)

(5 1 2 3)

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

#{:a :b :c}

(doall (concat (conj [] 42) [99 101]))

(42 99 101)

(update-in {:foo [:existing-key]} [:foo] conj :upsert-key)

{:foo [:existing-key :upsert-key]}

(-> [1]
    conj
    (->> (->> 10)))

[1 10]

(reduce conj {} {:a :b, :c :d})

{:a :b, :c :d}

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

(3 2 1)

(apply conj '{1 2} '())

{1 2}

(conj #{1 2 3} 2)

#{1 2 3}

(take 3 (reductions conj [] (repeat :a)))

([] [:a] [:a :a])

(conj '(a b c) 'd)

(d a b c)

(merge-with conj {:abc nil} {:abc :cde})

{:abc (:cde)}

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

{1 4, 2 5, 3 6}

(update-in [[:a :b]] [0] conj 1)

[[:a :b 1]]

(conj '(1 2 3) 4)

(4 1 2 3)

(conj (empty (conj (sorted-set-by #(> %1 %2)) 1 4 2)) 1 4 2)

#{1 2 4}

(conj '(:batman) (repeat 8 Double/NaN))

((##NaN ##NaN ##NaN ##NaN ##NaN ##NaN ##NaN ##NaN) :batman)

(flatten (conj [1 2] [3 4]))

(1 2 3 4)

(conj (sorted-set :e :d :c) :a)

#{:a :c :d :e}