**mapc***function*→`&rest`

lists`+`

*list-1***mapcar***function*→`&rest`

lists`+`

*result-list***mapcan***function*→`&rest`

lists`+`

*concatenated-results***mapl***function*→`&rest`

lists`+`

*list-1***maplist***function*→`&rest`

lists`+`

*result-list***mapcon***function*→`&rest`

lists`+`

*concatenated-results*

*list*- a*proper list*.*result-list*- a*list*.*concatenated-results*- a*list*.

The mapping operation involves applying *function* to successive sets of arguments in which one argument is obtained from each *sequence*. Except for **mapc** and **mapl**, the result contains the results returned by *function*. In the cases of **mapc** and **mapl**, the resulting *sequence* is *list*.

*function* is called first on all the elements with index `0`

, then on all those with index `1`

, and so on. *result-type* specifies the *type* of the resulting *sequence*. If *function* is a *symbol*, it is **coerce**d to a *function* as if by **symbol-function**.

**mapcar** operates on successive *elements* of the *lists*. *function* is applied to the first *element* of each *list*, then to the second *element* of each *list*, and so on. The iteration terminates when the shortest *list* runs out, and excess elements in other lists are ignored. The value returned by **mapcar** is a *list* of the results of successive calls to *function*.

**mapc** is like **mapcar** except that the results of applying *function* are not accumulated. The *list* argument is returned.

**maplist** is like **mapcar** except that *function* is applied to successive sublists of the *lists*. *function* is first applied to the *lists* themselves, and then to the *cdr* of each *list*, and then to the *cdr* of the *cdr* of each *list*, and so on.

**mapl** is like **maplist** except that the results of applying *function* are not accumulated; *list-1* is returned.

**mapcan** and **mapcon** are like **mapcar** and **maplist** respectively, except that the results of applying *function* are combined into a *list* by the use of **nconc** rather than **list**. That is,

(mapcon

fx1...xn) ≡ (apply #'nconc (maplistfx1...xn))

and similarly for the relationship between **mapcan** and **mapcar**.

(mapcar #'car '((1 a) (2 b) (3 c)))

→(1 2 3)

(mapcar #'abs '(3 -4 2 -5 -6))

→(3 4 2 5 6)

(mapcar #'cons '(a b c) '(1 2 3))

→((A . 1) (B . 2) (C . 3))

(maplist #'append '(1 2 3 4) '(1 2) '(1 2 3))

→((1 2 3 4 1 2 1 2 3) (2 3 4 2 2 3))

(maplist #'(lambda (x) (cons 'foo x)) '(a b c d))

→((FOO A B C D) (FOO B C D) (FOO C D) (FOO D))

(maplist #'(lambda (x) (if (member (car x) (cdr x)) 0 1)) '(a b a c d b c))

→(0 0 1 0 1 1 1)

;;; An entry is 1 if the corresponding element of the input list was the last instance of that element in the input list.

(defparameter *dummy-mapc* nil) → NIL

→*DUMMY-MAPC*

(mapc #'(lambda (&rest x) (setf *dummy-mapc* (append *dummy-mapc* x))) '(1 2 3 4) '(a b c d e) '(x y z))

→(1 2 3 4)

*dummy-mapc*

→(1 A X 2 B Y 3 C Z)

(defparameter *dummy-mapl* nil)

→*DUMMY-MAPL*

(mapl #'(lambda (x) (push x *dummy-mapl*)) '(1 2 3 4))

→(1 2 3 4)

*dummy-mapl*

→((4) (3 4) (2 3 4) (1 2 3 4))

In the below case, the function serves as a filter; this is a standard Lisp idiom using **mapcan**.

(mapcan #'(lambda (x y) (if (null x) nil (list x y))) '(nil nil nil d e) '(1 2 3 4 5 6))

→(D 4 E 5)

(mapcan #'(lambda (x) (and (numberp x) (list x))) '(a 1 b c 3 4 d 5))

→(1 3 4 5)

(mapcon #'list '(1 2 3 4))

→((1 2 3 4) (2 3 4) (3 4) (4))

None.

None.

Should be prepared to signal an error of type type-error if any *list* is not a *proper list*.

**Function DOLIST**, **Function MAP**, {\secref\TraversalRules}

To be done.

None.

\issue{FUNCTION-TYPE:X3J13-MARCH-88} \issue{MAPPING-DESTRUCTIVE-INTERACTION:EXPLICITLY-VAGUE} \issue{DOTTED-LIST-ARGUMENTS:CLARIFY}