clojure.core/into

View this page on ClojureDocs

Type: function Added: Clojure 1.0 Examples: 13 Runnable: 9

([] [to] [to from] [to xform from])

Returns a new coll consisting of to with all of the items of from conjoined. A transducer may be supplied. (into x) returns x. (into) returns [].

Examples

by Miki on 2010-07-11 ▶

; Maps can be constructed from a sequence of 2-vectors or a sequence ; of maps (into (sorted-map) [ [:a 1] [:c 3] [:b 2] ] ) {:a 1, :b 2, :c 3} (into (sorted-map) [ {:a 1} {:c 3} {:b 2} ] ) {:a 1, :b 2, :c 3} ; When maps are the input source, they convert into an unordered sequence ; of key-value pairs, encoded as 2-vectors (into [] {1 2, 3 4}) [[1 2] [3 4]]

by cran1988 on 2011-07-10 ▶

; Items are conj'ed one at a time, which puts them at the head of ; the destination list (into () '(1 2 3)) (3 2 1) ; This does not happen for a vector, however, due to the behavior of conj: (into [1 2 3] '(4 5 6)) [1 2 3 4 5 6]

by octopusgrabbus on 2012-04-17 ▶

(defn test-key-inclusion-cols "return all values in column1 that aren't in column2" [column1 column2] (filter (complement (into #{} column2)) column1))

by cloojure on 2014-05-08 ▶

; Change from one type of map to another (into (sorted-map) {:b 2 :c 3 :a 1}) {:a 1, :b 2, :c 3}

by dxlr8r on 2015-11-28 . May have evaluation errors. ▶

; Convert a nested ordering map to hash-map (or another) (use 'flatland.ordered.map) (def ord-map (ordered-map :a "a" :b "b" :c {:d "d" :e "e"})) ord-map #ordered/map ([:a "a"] [:b "b"] [:c {:d "d", :e "e"}]) (use 'clojure.walk) (defn disorder [ordering-map map-fn] (postwalk #(if (map? %) (into map-fn %) %) ordering-map)) (disorder ord-map {}) {:a "a", :b "b", :c {:d "d", :e "e"}}

by ha0ck on 2016-03-23 ▶

;impl apply merge (into {:x 4} [{:a 1} {:b 2} {:c 3}]) {:x 4, :a 1, :b 2, :c 3}

by fasiha on 2016-05-04 . May have evaluation errors. ▶

;; How do we use a transducer? ; Define the transducer with `comp` but in `->` order: (def xform (comp (map #(+ 2 %)) (filter odd?))) ; adds 2, then omits if result is even. (into [-1 -2] xform (range 10)) ; => [-1 -2 3 5 7 9 11] ; Alternatively, using `transduce` directly: (transduce xform conj [-1 -2] (range 10)) ; => [-1 -2 3 5 7 9 11] ; Alternatively, using reduce and explicitly calling `map` and `filter`: (reduce conj [-1 -2] (->> (range 10) (map #(+ 2 %)) (filter odd?))) ; => [-1 -2 3 5 7 9 11] ;; Let's benchmark, using Criterium (https://github.com/hugoduncan/criterium) (require '[criterium.core :refer [quick-bench]]) (quick-bench (into [-1 -2] xform (range 1000000))) ; Execution time lower quantile : 54.368948 ms ( 2.5%) ; Execution time upper quantile : 55.976303 ms (97.5%) (quick-bench (transduce xform conj [-1 -2] (range 1000000))) ; Execution time lower quantile : 77.738505 ms ( 2.5%) ; Execution time upper quantile : 87.088016 ms (97.5%): 1.5x slower than into (quick-bench (reduce conj [-1 -2] (->> (range 1000000) (map #(+ 2 %)) (filter odd?)))) ; Execution time lower quantile : 92.607522 ms ( 2.5%) ; Execution time upper quantile : 100.426780 ms (97.5%): 1.8x slower than into

by aksenov on 2016-12-20 . May have evaluation errors. ▶

;; Interesting case you can't directly convert list or sequence into map (due performance reasons). One should use vector instead. ;; This is ok: (into {} [[:a "a"] [:b "b"]]) ;;=> {:a "a", :b "b"} ;; But this isn't: (into {} ['(:a "a") '(:b "b")]) ;;=> ClassCastException clojure.lang.Keyword cannot be cast to java.util.Map$Entry clojure.lang.ATransientMap.conj (ATransientMap.java:44)

by phreed on 2018-02-06 ▶

;; merging two arrays using the transducer `cat` (into [] cat [[1 2 3 ] [4 5 6 ]]) ;=> [1 2 3 4 5 6] (into '() cat [[1 2 3 ] [4 5 6 ]]) ;=> (6 5 4 3 2 1) (into '() [1 2 3 4 5 6]) ;=> (6 5 4 3 2 1)

by lsevero on 2020-02-18 ▶

;Into is useful to concatenate vectors of maps (def a [{:a 1 :b 2} {:a 3 :b 4}]) (def b [{:c "c" :d "d"} {:c "cc" :d "dd"}]) (into a b) ;=> [{:a 1, :b 2} {:a 3, :b 4} {:c "c", :d "d"} {:c "cc", :d "dd"}] ;concat will return a similar result, but will be a lazy-seq instead of a vector

by littleli on 2020-05-04 . May have evaluation errors. ▶

;; Java 9 introduced immutable collections constructed with static 'of' methods ;; These collections have specific implementation details and are used usually along with Java streams ;; They cannot be used as operators like this (a-map :key) ;; Use 'into' to convert them to Clojure collections with improved utility (into [] (java.util.List/of :a :b :c)) ;=> [:a :b :c] (into #{} (java.util.Set/of :a :b :c)) ;=> #{:c :b :a} (into {} (java.util.Map/of :a "aa" :b "bb" :c "cc")) ;=> {:c "cc", :b "bb", :a "aa"}

by luiszambon on 2020-09-15 ▶

; into will return the coll type of the first parameter (def list-example '(1 2 3 4)) ;=> #'list-example (def vector-example [1 2 3 4]) ;=> #'vector-example (def set-example #{1 2 3 4}) ;=> #'set-example (class (into list-example vector-example)) ;=> clojure.lang.PersistentList (class (into vector-example list-example)) ;=> clojure.lang.PersistentVector (class (into set-example list-example)) ;=> clojure.lang.PersistentHashSet

by jacoobes on 2024-12-10 ▶

; I like adding commas to encourage readability (def nums #{ 1 2 3 4 5}) (into nums, [5 6 7]) ;=> #{1 2 3 4 5 6 7} ; commas are treated as whitespace (into nums [5 6 7]) ;=> #{1 2 3 4 5 6 7}

See also

• clojure.core/conj (9)
• clojure.core/concat (7)
• clojure.core/assoc (8)

---

Content from the matching ClojureDocs page, with authors credited on each contribution.