clojure.core/map

View this page on ClojureDocs

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

([f] [f coll] [f c1 c2] [f c1 c2 c3] [f c1 c2 c3 & colls])

Returns a lazy sequence consisting of the result of applying f to the set of first items of each coll, followed by applying f to the set of second items in each coll, until any one of the colls is exhausted. Any remaining items in other colls are ignored. Function f should accept number-of-colls arguments. Returns a transducer when no collection is provided.

Examples

by zk on 2010-07-10 ▶

(map inc [1 2 3 4 5]) ;;=> (2 3 4 5 6) ;; map can be used with multiple collections. Collections will be consumed ;; and passed to the mapping function in parallel: (map + [1 2 3] [4 5 6]) ;;=> (5 7 9) ;; When map is passed more than one collection, the mapping function will ;; be applied until one of the collections runs out: (map + [1 2 3] (iterate inc 1)) ;;=> (2 4 6) ;; map is often used in conjunction with the # reader macro: (map #(str "Hello " % "!" ) ["Ford" "Arthur" "Tricia"]) ;;=> ("Hello Ford!" "Hello Arthur!" "Hello Tricia!") ;; A useful idiom to pull "columns" out of a collection of collections. ;; Note, it is equivalent to: ;; user=> (map vector [:a :b :c] [:d :e :f] [:g :h :i]) (apply map vector [[:a :b :c] [:d :e :f] [:g :h :i]]) ;;=> ([:a :d :g] [:b :e :h] [:c :f :i]) ;; From http://clojure-examples.appspot.com/clojure.core/map

by nipra on 2010-07-13 . May have evaluation errors. ▶

;; map sends key-value pairs from a hash-map (map #(vector (first %) (* 2 (second %))) {:a 1 :b 2 :c 3}) ;;=> ([:a 2] [:b 4] [:c 6]) ;; or the same thing using destructuring (map (fn [[key value]] [key (* 2 value)]) {:a 1 :b 2 :c 3}) ;;=> ([:a 2] [:b 4] [:c 6]) (into {} *1) ;;=> {:a 2, :b 4, :c 6}

by shockbob on 2011-07-16 . May have evaluation errors. ▶

;; Use a hash-map as a function to translate values in a collection from the ;; given key to the associated value (map {2 "two" 3 "three"} [5 3 2]) (nil "three" "two") ;; then use (filter identity... to remove the nils (filter identity (map {2 "two" 3 "three"} [5 3 2])) ("three" "two") ;; an alternative to the above map+filter steps is keep. (keep {2 "two" 3 "three"} [5 3 2]) ;;=> ("three" "two")

by boxie on 2011-11-03 . May have evaluation errors. ▶

;; mapping over a hash-map applies (into) first. ;; need to use functions that deal with arrays (fn [[key val]] ...) (map pprint {:key :val :key1 :val1}) ([:key :val] [:key1 :val1] nil nil) ;;above, the pprint output appears to be part of the return value but it's not: (hash-set (map pprint {:key :val :key1 :val1})) [:key :val] [:key1 :val1] #{(nil nil)} (map second {:key :val :key1 :val1}) ;;=>(:val :val1) (map last {:x 1 :y 2 :z 3}) ;;=> (1 2 3)

by dansalmo on 2012-08-16 . May have evaluation errors. ▶

(map fn [a 4 x] [b 5 y] [c 6]) ; ^ ^ ; applies fn to a b c as (fn a b c) ; applies fn to 4 5 6 as (fn 4 5 6) ; ignores (x y) ; returns a list of results ; equivalent to (list (fn a b c) (fn 4 5 6)) ;example (map list [1 2 3] '(a b c) '(4 5)) (map list [1 2 3] '(a b c) '(4 5)) ((1 a 4) (2 b 5)) ;same as (list (list 1 'a 4) (list 2 'b 5)) ((1 a 4) (2 b 5))

by octopusgrabbus on 2013-06-14 ▶

; map passed two collection arguments. From 4Clojure Problem #157 (def d1 [:a :b :c]) (#(map list % (range)) d1) ;;=> ((:a 0) (:b 1) (:c 2))

by bsvingen on 2015-07-02 ▶

;; Used without a collection, map will create a transducer: (def xf (map inc)) ;; We can now apply this transducer to a sequence: (transduce xf conj (range 5)) ;; => [1 2 3 4 5]

by ha0ck on 2015-12-14 ▶

;; Extract keyword from a collection of obj (map :a '({:a 1 :b 0} {:a 2 :b 0} {:a 3 :b 1} {:a 3 :b 0})) ;; =>(1 2 3 3)

by sleyzerzon on 2016-08-14 ▶

;;get the keys from a map with entries of certain values (let [m {:x 1 :y 2 :z 3} vset #{2 3}] (map first (filter (comp vset last) m))) ;;=> (:y :z) (filter (comp #{2 3} last) {:x 1 :y 2 :z 3}) ;;=> ([:y 2] [:z 3])

by phreed on 2018-01-12 ▶

;; deeper destructuring (def ds [ {:a 1 :b 2 :c [:foo :bar]} {:a 9 :b 8 :c [:baz :zoo]} {:a 1 :b 2 :c [:dog :cat]} ]) (->> ds (map (fn [{a :a, b :b, [lhs rhs] :c}] [(str "a:" a " c2:" rhs)]))) ;;=> (["a:1 c2::bar"] ["a:9 c2::zoo"] ["a:1 c2::cat"])

by ibercode on 2018-01-22 ▶

;;map taking a collection of functions as an argument (def sum #(reduce + %)) (def average #(/ (sum %) (count %))) ;;apply a function to a collection (defn results [coll] (map #(% coll) [sum average count])) (results [10 20 30 40 50]) ;;[150 30 5]

by ibercode on 2018-01-27 ▶

(def my-coll [ {:m 1, :val 12} {:m 2, :val 3} {:m 3, :val 32}]) (map #(:val %) my-coll) ;;(12 3 32) ;;get total: (reduce + (map #(:val %) my-coll)) ;;47

by ibercode on 2018-02-04 ▶

;;map practical example (def months ["jan" "feb" "mar"]) (def temps [5 7 12]) (defn unify [month temp] {:month month :temp temp}) (map unify months temps) ;;({:month "jan", :temp 5} ;; {:month "feb", :temp 7} ;; {:month "mar", :temp 12})

by ibercode on 2018-02-15 ▶

;;map Function collection1 collection2 (map vector '(1 2 3 4) [:a :b :c :d]) ;;([1 :a] [2 :b] [3 :c] [4 :d])

by sodesu99 on 2019-06-08 ▶

;multiplication of rows and columns (def matrix [ [1 2 3 4 5];=>120 [1 2 3 4 5];=>120 [1 2 3 4 5];=>120 [1 2 3 4 5]]);120 ;(1 16 81 256 625) ;;columns multiplication (apply map * matrix) ;;(1 16 81 256 625) ;;rows multiplication (map #(reduce * %) matrix) ;;(120 120 120 120)

by cloudbuck3t on 2021-09-10 . May have evaluation errors. ▶

;; Notice how the args of each collection are processed in parallel by the ;; function provided to `map` -- in this case, an #(anonymous function) ;;that takes %1 = the first coll elements and %2 the second coll elements. ;; map will process the collections in parallel and will terminate when it reaches ;; the end of the shortest collection. In this case, they are equal length. (map #(str "Hello " %1 %2) ["Tennessee " "James " "John "] ["Ernie Ford" "Bond" "Smith"]) output> ("Hello Tennessee Ernie Ford" "Hello James Bond" "Hello John Smith")

by aQuaYi on 2021-11-13 ▶

;; running several functions on the same argument (map #(% 0) (list inc dec zero?)) ;=> (1 -1 true) (map #(% 0) [inc dec zero?]) ;=> (1 -1 true) ;; but not (map #(% 0) `(inc dec zero?)) ;=> (nil nil nil) (map #(% 0) '(inc dec zero?)) ;=> (nil nil nil) ;; https://stackoverflow.com/questions/69925317/why-map-fn-f-f-0-inc-returns-nil-in-clojure

by holtzermann17 on 2022-04-17 ▶

;; Be careful with `map`, closures, and anonymous functions (defn typical-closure [] (let [names (atom [])] (fn [arg] (swap! names conj arg) @names))) ;; This works as expected: one function gets created and mapped (defmacro list-maker [fun args & body] `(defn ~fun ~args (map (typical-closure) '~body))) (list-maker foo [x] 1 2 3 4 5) (foo 100) ; ([1] [1 2] [1 2 3] [1 2 3 4] [1 2 3 4 5]) ;; This version recomputes the function for each mappand! (defmacro list-maker-oops [fun args & body] `(defn ~fun ~args (map #((typical-closure) %) '~body))) ;; facepalm (list-maker-oops foo [x] 1 2 3 4 5) (foo 100) ; ([1] [2] [3] [4] [5])

Note by Howard Abrams

To create a hashmap, use the hash-map function, or the {...} sugar:

(= {:a 1 :b 2 :c 3} (hash-map :a 1 :b 2 :c 3))

See also

• clojure.core/map-indexed (4)
• clojure.core/pmap (3)
• clojure.core/amap
• clojure.core/mapcat (7)
• clojure.core/keep (8)
• clojure.core/juxt (7)
• clojure.core/mapv (3)
• clojure.core/reduce (22)
• clojure.core/run! (1)
• clojure.core/filter (6)

---

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