Elisp: Map List/Vector

Map: mapcar

Typical way to go thru a Sequence is using mapcar. Note that it returns a list, even if input is a vector.

(mapcar FUNCTION SEQUENCE)

Apply FUNCTION to each element of SEQUENCE, and make a list of the results. The result is a list, with same length as SEQUENCE. SEQUENCE may be a list, a vector, a bool-vector, or a string.

;; add 1 to each vector element
(mapcar '1+ [3 4 5] ) ; (4 5 6)

;; add one to each list element
(mapcar '1+ '(3 4 5)) ; (4 5 6)

1+ is a lisp function. It adds 1 to argument and returns it. For example, (1+ 2) returns 3.

To use a function in mapcar, you need to quote the function's name.

1+ is a function, so we quote it and have '1+ or (quote 1+)

Here's another example.

; take the 1st element of each
(mapcar 'car '((1 2) (3 4) (5 6))) ; (1 3 5)

mapcar with lambda

mapcar is most commonly used with lambda. Here's a example:

;; get first element of each row
(mapcar
 (lambda (x) (elt x 0))
 [[1 2] [3 4]] ) ; ⇒ (1 3)

lambda means function, often known as “anonymous function”. It let you define a function in the middle of your code.

The form is (lambda (args) body).

For example, (lambda (x y) (+ x y)) is a function that takes two arguments, x and y, and returns their sum.

More examples with lambda:

; add one to each list member
(mapcar
 (lambda (x) (+ x 1))
 (list 1 2 3 4)
) ; (2 3 4 5)

;; take the 2nd element of each
(mapcar (lambda (x) (nth 1 x))
        '((1 2) (3 4) (5 6))) ; (2 4 6)

mapc (foreach)

If you don't need map to return the sequence, use mapc.

mapc is like mapcar, but returns nil.

;; apply a file processing function to a list of files
(mapc 'my-update-html-footer
      (list
       "~/file1.html"
       "~/file2.html"
       "~/file3.html"
       ))

;; example of mapc on vector
(mapc
 (lambda (x)
   (insert (number-to-string (aref x 0))))
 [[1 2] [3 4]] )

;; insert first element of each row into buffer
;; (it inserts 13)
;; returns nil

Loop Thru a List (dolist)

(dolist (VAR LIST) BODY)

Loop over a list. Evaluate BODY with VAR bound to each element from LIST, returns nil.

(dolist (VAR LIST RESULT) BODY)

returns RESULT.

(let (
      (xlist (number-sequence 97 122)) ;; list 97 to 122
      )
  (dolist (n xlist) (insert n)))

;; inserts
;; abcdefghijklmnopqrstuvwxyz

The major difference between dolist and mapc is that dolist uses expression, mapc uses a function. Also, dolist work with list only, mapc works with list and vectors.

Loop Fixed Number of Times (dotimes)

dotimes is useful when you want to go thru a list by a increasing index.

(dotimes (VAR COUNT) BODY …)

Loop a certain number of times. Evaluate BODY with VAR bound to successive integers running from 0, inclusive, to COUNT, exclusive. Returns nil

(dotimes (VAR COUNT RESULT) BODY …)

After loop, evaluate RESULT to get the return value.

(dotimes (i 4)
  (insert (number-to-string i)))
;; inserts "0123", returns nil

(let ((v [3 4 5]))
  (dotimes (i (length v))
    (insert
     (number-to-string
      (elt v i))))) ; inserts 345

while Loop

Another common form to loop thru a list is using the while function. In each iteration, pop is used to reduce the list.

(let ((mylist '(a b c)))
  (while mylist
    (message "%s" (pop mylist))
    (sleep-for 1)))

Example with vector:

(setq v [3 4 5])
(setq i 0)

(while (< i (length v))
  (insert (format "%d" (elt v i)))
  (setq i (1+ i))) ; inserts "345"

Exit Loop/Function, catch/throw

Elisp: throw, catch