**Syntax:**

**mapc** *function &rest lists+* =>

**mapcar** *function &rest lists+* =>

**mapcan** *function &rest lists+* =>

**mapl** *function &rest lists+* =>

**maplist** *function &rest lists+* =>

**mapcon** *function &rest lists+* =>

**Arguments and Values:**

*function*---a *designator* for a *function* that must take as many *arguments* as there are *lists*.

*list*---a *proper list*.

*list-1*---the first *list* (which must be a *proper list*).

*result-list*---a *list*.

*concatenated-results*---a *list*.

**Description:**

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 f x1 ... xn) == (apply #'nconc (maplist f x1 ... xn))and similarly for the relationship between

**Examples:**

(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. (setq dummy nil) => NIL (mapc #'(lambda (&rest x) (setq dummy (append dummy x))) '(1 2 3 4) '(a b c d e) '(x y z)) => (1 2 3 4) dummy => (1 A X 2 B Y 3 C Z) (setq dummy nil) => NIL (mapl #'(lambda (x) (push x dummy)) '(1 2 3 4)) => (1 2 3 4) dummy => ((4) (3 4) (2 3 4) (1 2 3 4)) (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)In this case the function serves as a filter; this is a standard Lisp idiom using

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

**Affected By:** None.

**Exceptional Situations:**

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

**See Also:**

**dolist**, **map**, Section 3.6 (Traversal Rules and Side Effects)

**Notes:** None.

The following X3J13 cleanup issues,

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