(class (conj [:b] :a))

clojure.lang.PersistentVector

(conj '(false) true)

(true false)

(reverse (conj [1] 2))

(2 1)

(reduce conj [] (range 5))

[0 1 2 3 4]

(def pc (partial conj))

#'user/pc

(conj [1 2] 2)

[1 2 2]

(conj [1] 0 0)

[1 0 0]

(conj #{:foo} :bar)

#{:bar :foo}

(= (conj [:a :b :c] :x) (conj '(:a :b :c) :x))

false

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

[3]

(def set-conj (fnil conj #{}))

#'user/set-conj

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

{:list [:a]}

(seq (conj () 1 2 3))

(3 2 1)

(conj '(0 1) 4)

(4 0 1)

(conj '(4 5) 1)

(1 4 5)

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

{:foo [:x]}

(conj [1 2 3] :zoo)

[1 2 3 :zoo]

(conj {} (find {:foo nil} :foo))

{:foo nil}

((fnil conj #{}) nil 5)

#{5}

(conj (seq [1 2]) 3)

(3 1 2)

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

{:bar 2, :foo 1}

(conj [:a :b :c] :bar)

[:a :b :c :bar]

(conj (seq (range 10)) -1)

(-1 0 1 2 3 4 5 6 7 8 9)

((fnil conj {}) nil {:a 0})

{:a 0}

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

{:owner 2, :title "stuff"}

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

{[:foo :bar] [:baz :blah]}

(conj {} {:id 1, :value 42})

{:id 1, :value 42}

(conj [1 2 3] 10)

[1 2 3 10]

(str (conj (seq "ola") \h))

"(\\h \\o \\l \\a)"

(-> :a
    ((partial conj #{})))

#{:a}

(conj (set ["a" "b"]) "c")

#{"a" "b" "c"}

(reduce conj [1] [0 0])

[1 0 0]

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

{:a 1, :b 2}

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

[{:a :b, :c :c}]

(conj (pop [1 2]) 3)

[1 3]

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

{:good [3]}

(reduce conj nil (range 10))

(9 8 7 6 5 4 3 2 1 0)

(conj [1 2 3] 4)

[1 2 3 4]

(conj #{} 1 2 2)

#{1 2}

(conj [1 2 3] 4)

[1 2 3 4]

(class (conj [1 2] 3))

clojure.lang.PersistentVector

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

{:wtf ["LOL"]}

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

clojure.lang.Cons

(conj [1 2 3] 'x)

[1 2 3 x]

(conj [1 2 3] 4)

[1 2 3 4]

(seq (conj [] 1 2 3))

(1 2 3)

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

{:a 1, :b 2}

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

{"d" ["2"]}

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

{:foo "baz"}

(conj '(1 2) 3)

(3 1 2)