clojure.core/mapv

View this page on ClojureDocs

Type: function Added: Clojure 1.4 Examples: 3 Runnable: 3

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

Returns a vector 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.

Examples

by phreed on 2015-01-12 ▶

(mapv inc [1 2 3 4 5]) ;;=> [2 3 4 5 6] ;; mapv can be used with multiple collections. Collections will be consumed ;; and passed to the mapping function in parallel: (mapv + [1 2 3] [4 5 6]) ;;=> [5 7 9] ;; When mapv is passed more than one collection, the mapping function will ;; be applied until one of the collections runs out: (mapv + [1 2 3] (iterate inc 1)) ;;=> [2 4 6] ;; mapv is often used in conjunction with the # reader macro: (mapv #(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: ;; (mapv vector [:a :b :c] [:d :e :f] [:g :h :i]) (apply mapv vector [[:a :b :c] [:d :e :f] [:g :h :i]]) ;;=> [[:a :d :g] [:b :e :h] [:c :f :i]]

by kangbb on 2019-11-14 ▶

;; The difference between `map` and `mapv` is that: ;; `map` return a lazy sequence, ;; `mapv` return a sequence. (def result (map println [1 2 3])) ;;=> #'user/result result ;;=> 1 ;; 2 ;; 3 ;; (nil nil nil) (def result (mapv println [1 2 3])) ;;=> 1 ;; 2 ;; 3 ;; #'user/result result ;;=> [nil nil nil] ;; So, we can use it when we want to get a side effect immediately.

by sFritsch09 on 2021-04-21 ▶

;; convert number to vector: ; numb = 210 ((fn [numb] (mapv #(Character/digit % 10) (str numb))) 210) ;;=> [2 1 0] ;; and the other way around: (read-string (reduce str [2 1 0])) ;;=> 210

Note by num1

Like map but returns a vector. In most cases equivalent to calling (into [] (map f c1 c2 ...)). Is much faster than map (but is not lazy!) in the (mapv f coll) case.

Note by KingMob

It's not necessarily true at all that mapv will be faster than map. mapv (and related fns like filterv) have increased memory needs (creating unused values, realizing intermediate sequences, etc) that hurt it.

Here's a simple example showing how mapv/filterv can be slower. (Benchmarked with criterium.)

(let [nums (range 10000000)]
  (bench
    (reduce +' 0 (filter even? (map #(* % %) nums))))

  (bench
    (reduce +' 0 (filterv even? (mapv #(* % %) nums)))))

and the results, showing map is actually a little faster than mapv:

Evaluation count : 120 in 60 samples of 2 calls.
             Execution time mean : 768.870217 ms
    Execution time std-deviation : 21.043586 ms
   Execution time lower quantile : 756.049838 ms ( 2.5%)
   Execution time upper quantile : 835.719808 ms (97.5%)
                   Overhead used : 1.805367 ns

Found 9 outliers in 60 samples (15.0000 %)
    low-severe   3 (5.0000 %)
    low-mild     6 (10.0000 %)
 Variance from outliers : 14.2178 % Variance is moderately inflated by outliers



Evaluation count : 120 in 60 samples of 2 calls.
             Execution time mean : 800.356084 ms
    Execution time std-deviation : 49.667013 ms
   Execution time lower quantile : 756.382597 ms ( 2.5%)
   Execution time upper quantile : 883.471627 ms (97.5%)
                   Overhead used : 1.805367 ns

Found 12 outliers in 60 samples (20.0000 %)
    low-severe   5 (8.3333 %)
    low-mild     1 (1.6667 %)
    high-mild    6 (10.0000 %)
 Variance from outliers : 46.7536 % Variance is moderately inflated by outliers

The takeaway is, don't pick mapv just for speed reasons.

See also

• clojure.core/map (13)
• clojure.core/vec (1)
• clojure.core/reduce (22)
• clojure.core/pmap (3)

---

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