(conj #{:a "a" 'a} \a)

#{:a \a a "a"}

(conj (set '("item-a" "item-b")) "item-c")

#{"item-a" "item-b" "item-c"}

(conj '(b c d) 'a)

(a b c d)

(reductions conj [] [1 2 4 8])

([] [1] [1 2] [1 2 4] [1 2 4 8])

(conj (list "one" "two" "three") "four")

("four" "one" "two" "three")

(update-in nil "some string" conj 2)

{\s {\o {\m {\e {\space {\s {\t {\r {\i {\n {\g (2)}}}}}}}}}}}

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

#{{:a 1}}

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

{1 2, 3 4}

(type (rest (conj (range 3) 4)))

clojure.lang.LongRange

(update-in {} [:foo] (fnil conj #{}) "bar")

{:foo #{"bar"}}

(= (conj #{} *ns*) #{*ns*})

true

(update-in {:foo nil} [:foo] conj :x)

{:foo (:x)}

(meta (with-meta (conj () 1) {:foo true}))

{:foo true}

(conj '(1 2 3) 1)

(1 1 2 3)

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

(3 1 2 3)

(let [x []]
  (conj x "1")
  x)

[]

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

#{:a :b :c}

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

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

(list? (conj '(1 2) 3))

true

(conj [1 2 3 4] 0)

[1 2 3 4 0]

(meta ^{:foo true} (conj () 1))

{:column 26, :line 1}

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

{1 2, 3 4}

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

#{:a :b :c}

(conj (list 1 2 3) 'a)

(a 1 2 3)

(class ((update-in {} [1] conj 2) 1))

clojure.lang.PersistentList

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

{:deletes (1 12 13)}

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

clojure.lang.PersistentVector

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

{:a [0 1]}

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

#{1 2 3}

(type (conj (list 2 3) 1))

clojure.lang.PersistentList

(let [x #{}] (conj x 'a))

#{a}

(conj '(2 3 4) 1)

(1 2 3 4)

(conj (list 1 2 3) 4)

(4 1 2 3)

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

{:foo #{1}}

(conj [1 2 4 8] 5)

[1 2 4 8 5]

(conj (rseq [1 2 3]) :x)

(:x 3 2 1)

(conj '[1 2 3] 4)

[1 2 3 4]

(conj '(1 2 3) :a)

(:a 1 2 3)

(conj (drop-last 2 (range 10)) 1)

(1 0 1 2 3 4 5 6 7)

(conj '(1 2 3) 7)

(7 1 2 3)

(counted? (conj '(3 7) 10))

true

(conj (list 1 2 3) :a)

(:a 1 2 3)

(rest (reductions conj [] [1 2 3]))

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

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

{:a [1 2]}

(conj '(1 2 3) :zoo)

(:zoo 1 2 3)

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

[[0] [0 1]]

(conj '(1 2 3) 'x)

(x 1 2 3)

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

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

(next (reductions conj [] [1 2 3]))

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

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

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