((comp set conj) nil 1)

#{1}

(conj [1 2 3] 7)

[1 2 3 7]

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

{:a :b, :foo :bar}

(conj [1 2 3] :a)

[1 2 3 :a]

(apply conj [2] [2 3])

[2 2 3]

(conj '(3 4) 2)

(2 3 4)

(conj [1 2 3] 4)

[1 2 3 4]

(conj [2 3 5] '1)

[2 3 5 1]

(reductions conj [] (range 1 5))

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

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

{[1 2] [3 4]}

(update-in {:good []} [:good] conj "100")

{:good ["100"]}

(conj '(1) '(2))

((2) 1)

(update {:list []} :list conj :a)

{:list [:a]}

(reduce conj (list) (range 5))

(4 3 2 1 0)

(class (conj (list 0) 1))

clojure.lang.PersistentList

(conj (list 1 2) 3)

(3 1 2)

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

{:a 1, :b 2}

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

{:a :b, :c :d}

(take 5 (conj (range) -1))

(-1 0 1 2 3)

(conj () 4 3 2 1)

(1 2 3 4)

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

[(84519)]

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

{:a [3]}

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

#{#{:a :b}}

(conj '(1 2) 1)

(1 1 2)

(conj (vec (range 10)) :hi)

[0 1 2 3 4 5 6 7 8 9 :hi]

(def conjs (fnil conj #{}))

#'user/conjs

(conj {:a 3} {:b 7})

{:a 3, :b 7}

(defn subsets [s] (reduce #(conj %1 (conj (or (last %1) []) %2)) [] s))

#'user/subsets

(-> (sorted-set-by #(< (%1 1) (%2 1)))
    (conj [1 3])
    (conj [2 3]))

#{[1 3]}

(reduce #(conj %1 (conj [%2 (vec (flatten (reverse (last %1))))]))
  []
  [:a :b :c])

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

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

{:a :b, :c :d}

(conj {:foo "bar"} [:foo "baz"])

{:foo "baz"}

(update {:a []} :a conj 1)

{:a [1]}

(class (conj (or nil []) 3))

clojure.lang.PersistentVector

(type (conj (range 3) 4))

clojure.lang.Cons

(conj (drop-last [0 1]) 2)

(2 0)

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

{:a [42]}

(class ((fnil conj []) nil 2))

clojure.lang.PersistentVector

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

{:foo ["bar"]}

(apply swap! (atom #{}) conj [])

#{}

(counted? (conj (range 10) 2))

false

(update-in {} [:test] (fnil conj []) :val)

{:test [:val]}

(conj #{} "foo" "bar" "qux")

#{"bar" "foo" "qux"}

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

{:a 1, :b 2}

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

[[1 2] [1 3]]

(conj [1 2 3] 8)

[1 2 3 8]

(reduce conj [] [7 8 9])

[7 8 9]

(merge-with (fnil conj [] []) {:a []} {:b []})

{:a [], :b []}

(type (conj [1 2] 3))

clojure.lang.PersistentVector

(conj [0 2 3] 4)

[0 2 3 4]