(conj #{"foo"} (str "fo" "o"))

#{"foo"}

(update-in {:a #{}} [:a] conj :bar)

{:a #{:bar}}

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

[[[(:a)]]]

(conj (take 5 (range 10)) :end)

(:end 0 1 2 3 4)

(conj '(3 4) 2 1)

(1 2 3 4)

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

clojure.lang.PersistentVector

(reduce conj [1] (repeat 3 nil))

[1 nil nil nil]

(conj #{8 9} 9 10)

#{8 9 10}

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

[1 2 3]

(reduce conj [] #{7 8 4})

[7 4 8]

(reduce conj nil [1 2 3])

(3 2 1)

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

(1 1 2 3)

(conj [1 2 3] "your string")

[1 2 3 "your string"]

(class (conj {:x :y} [:j :k]))

clojure.lang.PersistentArrayMap

(reductions conj [] '(abc project id))

([] [abc] [abc project] [abc project id])

(map type [(cons 7 ()) (conj () 7)])

(clojure.lang.Cons clojure.lang.PersistentList)

(conj nil count [1 2 3])

([1 2 3] #object [clojure.core$count 0x5f5fa045 "clojure.core$count@5f5fa045"])

(reduce (fn [acc el] (if (= el 5) (reduced (conj acc el)) (conj acc el)))
  []
  (range))

[0 1 2 3 4 5]

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

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

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

{:a [0], :b [1]}

(for [i (range 1 4)] (conj [] i))

([1] [2] [3])

(merge-with conj (list {:words "hello"} {:words "world"}))

({:words "hello"} {:words "world"})

(conj ["git" "commit"] "-a" "-m" "lerl]")

["git" "commit" "-a" "-m" "lerl]"]

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

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

(conj (vec '(1 2 3)) 4)

[1 2 3 4]

(conj #{2} (denominator 1/2) (long 2))

#{2}

(reduce + (conj [] (repeat 1 (rand-int 100000))))

(43717)

(conj [1 2 3 4 5] 55)

[1 2 3 4 5 55]

(pop (conj '(1 2 3) 4))

(1 2 3)

(conj {:owner 2} {:title "stuff", :owner 33})

{:owner 33, :title "stuff"}

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

[0 1 2 3 4 5 6 7 1]

(conj [1 2 3] 4 5 6)

[1 2 3 4 5 6]

(conj {1 1} [2 2] [1 2])

{1 2, 2 2}

(conj '(2 3) -1 0 1)

(1 0 -1 2 3)

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

{:wtf ["LOL"]}

(reductions conj () '(1 2 3 4))

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

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

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

(reduce + (conj [] (repeat 1 (rand-int 100000))))

(22492)

(= (conj [[5 6] [7 8]] [0 1]) (conj '([5 6] [7 8]) [0 1]))

false

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

(4 3 2 1)

(conj (pop (list 1 2 3)) 0)

(0 2 3)

(map conj [1 2 3 4 5])

(1 2 3 4 5)

(-> []
    (with-meta {:foo 1})
    (conj :x)
    meta)

{:foo 1}

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

{:deletes (1 12 13)}

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

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

(apply merge-with conj [{:hello [1]} {:hello [2]}])

{:hello [1 [2]]}

(rest (reductions conj [] '(abc project id)))

([abc] [abc project] [abc project id])

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

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

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

clojure.lang.Cons

(reduce conj {} (list {:words "hello"} {:words "world"}))

{:words "world"}