function | since v0.0-927 | clojure.core/map | Edit |

`(map f)`

`(map f coll)`

`(map f c1 c2)`

`(map f c1 c2 c3)`

`(map f c1 c2 c3 & colls)`

Returns a lazy sequence of applying function `f`

to every element of `coll`

.

When more than one collection is provided, returns a lazy sequence consisting of
the result of applying `f`

to the set of first items of each `c`

, followed by
applying `f`

to the set of second items in each `c`

, until any one of the `c`

s
is exhausted. Any remaining items in other `c`

s are ignored. Function `f`

should
accept number-of-`c`

s arguments.

Returns a transducer when no collection is provided.

Source 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 collection is provided.

Source code @ clojurescript:src/main/cljs/cljs/core.cljs

```
(defn map
([f]
(fn [rf]
(fn
([] (rf))
([result] (rf result))
([result input]
(rf result (f input)))
([result input & inputs]
(rf result (apply f input inputs))))))
([f coll]
(lazy-seq
(when-let [s (seq coll)]
(if (chunked-seq? s)
(let [c (chunk-first s)
size (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))))))
```