store/[org.clojure/clojure "1.6.0"] clj::clojure.core/map

Community Documentation

Edit

Arities

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

Docstring

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 collections are provided.

Source

(defn map
  "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."
  {:added "1.0"
   :static true}
  ([f coll]
   (lazy-seq
    (when-let [s (seq coll)]
      (if (chunked-seq? s)
        (let [c (chunk-first s)
              size (int (count c))
              b (chunk-buffer size)]
          (dotimes [i size]
              (chunk-append b (f (.nth c i))))
          (chunk-cons (chunk b) (map f (chunk-rest s))))
        (cons (f (first s)) (map f (rest s)))))))
  ([f c1 c2]
   (lazy-seq
    (let [s1 (seq c1) s2 (seq c2)]
      (when (and s1 s2)
        (cons (f (first s1) (first s2))
              (map f (rest s1) (rest s2)))))))
  ([f c1 c2 c3]
   (lazy-seq
    (let [s1 (seq c1) s2 (seq c2) s3 (seq c3)]
      (when (and  s1 s2 s3)
        (cons (f (first s1) (first s2) (first s3))
              (map f (rest s1) (rest s2) (rest s3)))))))
  ([f c1 c2 c3 & colls]
   (let [step (fn step [cs]
                 (lazy-seq
                  (let [ss (map seq cs)]
                    (when (every? identity ss)
                      (cons (map first ss) (step (map rest ss)))))))]
     (map #(apply f %) (step (conj colls c3 c2 c1))))))

Example 1

Edit
;; 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)

Example 2

Edit
(map #(vector (first %) (* 2 (second %)))
     {:a 1 :b 2 :c 3})
;; => ([:a 2] [:b 4] [:c 6])

(into {} *1)
;; => {:a 2, :b 4, :c 6}

Example 3

Edit
; map passed two collection arguments. From 4Clojure Problem #157

(def d1 [:a :b :c])
(#(map list % (range)) d1)
((:a 0) (:b 1) (:c 2))

Example 4

Edit
(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:
;; (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

Example 5

Edit
;; 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")

Example 6

Edit
;; (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))

(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))

Uses on crossclj