5 Examples top

• link | changes

  user=> (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:
  user=> (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:
  user=> (map + [1 2 3] (iterate inc 1))
  (2 4 6)
  
  
  
  ;; map is often used in conjunction with the # reader macro:
  user=> (map #(str "" % "") ["the" "quick" "brown" "fox"])
  ("the" "quick" "brown" "fox")
  
  ;; A useful idiom to pull "columns" out of a collection of collections:
  user=> (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

  user=> (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: user=> (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: user=> (map + [1 2 3] (iterate inc 1)) (2 4 6) ;; map is often used in conjunction with the # reader macro: user=> (map #(str "" % "") ["the" "quick" "brown" "fox"]) ("the" "quick" "brown" "fox") ;; A useful idiom to pull "columns" out of a collection of collections: user=> (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
• link | changes

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

  user=> (map #(vector (first %) (* 2 (second %))) {:a 1 :b 2 :c 3}) ([:a 2] [:b 4] [:c 6]) user=> (into {} *1) {:a 2, :b 4, :c 6}
• link | changes

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

  ;; Use a hash-map as a function to translate values in a collection from the ;; given key to the associated value user=> (map {2 "two" 3 "three"} [5 3 2]) (nil "three" "two") ;; then use (filter identity... to remove the nils user=> (filter identity (map {2 "two" 3 "three"} [5 3 2])) ("three" "two")
• link | changes

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

  ;; 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)
• link | changes

  (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))
  
  user=> (map list  [1 2 3] '(a b c) '(4 5))
  ((1 a 4) (2 b 5))
  ;same as
  user=> (list (list 1 'a 4) (list 2 'b 5))
  ((1 a 4) (2 b 5))

  (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)) user=> (map list [1 2 3] '(a b c) '(4 5)) ((1 a 4) (2 b 5)) ;same as user=> (list (list 1 'a 4) (list 2 'b 5)) ((1 a 4) (2 b 5))