Evaluating forms in the order they appear is the most common way control passes from one form to another. In some contexts, such as in a function body, this happens automatically. Elsewhere you must use a control structure construct to do this: progn, the simplest control construct of Lisp. A progn special form looks like this:

(progn A B C ...)

and it says to execute the forms a, b, c, and so on, in that order. These forms are called the body of the progn form. The value of the last form in the body becomes the value of the entire progn. (progn) returns nil. In the early days of Lisp, progn was the only way to execute two or more forms in succession and use the value of the last of them. But programmers found they often needed to use a progn in the body of a function, where (at that time) only one form was allowed. So the body of a function was made into an implicit progn: several forms are allowed just as in the body of an actual progn. Many other control structures likewise contain an implicit progn. As a result, progn is not used as much as it was many years ago. It is needed now most often inside an unwind-protect, and, or, or in the then-part of an if.

progn

This special form evaluates all of the forms, in textual order, returning the result of the final form.

(progn (print "The first form")
       (print "The second form")
       (print "The third form"))
     -| "The first form"
     -| "The second form"
     -| "The third form"
=> "The third form"

Two other constructs likewise evaluate a series of forms but return different values:

prog1

This special form evaluates form1 and all of the forms, in textual order, returning the result of form1.

(prog1 (print "The first form")
       (print "The second form")
       (print "The third form"))
     -| "The first form"
     -| "The second form"
     -| "The third form"
=> "The first form"

Here is a way to remove the first element from a list in the variable x, then return the value of that former element:

(prog1 (car x) (setq x (cdr x)))

prog2

This special form evaluates form1, form2, and all of the following forms, in textual order, returning the result of form2.

(prog2 (print "The first form")
       (print "The second form")
       (print "The third form"))
     -| "The first form"
     -| "The second form"
     -| "The third form"
=> "The second form"

Conditional control structures choose among alternatives. Emacs Lisp has five conditional forms: if, which is much the same as in other languages; when and unless, which are variants of if; cond, which is a generalized case statement; and pcase, which is a generalization of cond (Pattern-Matching Conditional).

if

if chooses between the then-form and the else-forms based on the value of condition. If the evaluated condition is non-nil, then-form is evaluated and the result returned. Otherwise, the else-forms are evaluated in textual order, and the value of the last one is returned. (The else part of if is an example of an implicit progn. Sequencing.) If condition has the value nil, and no else-forms are given, if returns nil. if is a special form because the branch that is not selected is never evaluated—it is ignored. Thus, in this example, true is not printed because print is never called:

(if nil
    (print 'true)
  'very-false)
=> very-false

when

This is a variant of if where there are no else-forms, and possibly several then-forms. In particular,

(when CONDITION A B C)

is entirely equivalent to

(if CONDITION (progn A B C) nil)

unless

This is a variant of if where there is no then-form:

(unless CONDITION A B C)

is entirely equivalent to

(if CONDITION nil
   A B C)

cond

cond chooses among an arbitrary number of alternatives. Each clause in the cond must be a list. The CAR of this list is the condition; the remaining elements, if any, the body-forms. Thus, a clause looks like this:

(CONDITION BODY-FORMS...)

cond tries the clauses in textual order, by evaluating the condition of each clause. If the value of condition is non-nil, the clause succeeds; then cond evaluates its body-forms, and returns the value of the last of body-forms. Any remaining clauses are ignored. If the value of condition is nil, the clause fails, so the cond moves on to the following clause, trying its condition. A clause may also look like this:

(CONDITION)

Then, if condition is non-nil when tested, the cond form returns the value of condition. If every condition evaluates to nil, so that every clause fails, cond returns nil. The following example has four clauses, which test for the cases where the value of x is a number, string, buffer and symbol, respectively:

(cond ((numberp x) x)
      ((stringp x) x)
      ((bufferp x)
       (setq temporary-hack x) ; multiple body-forms
       (buffer-name x))        ; in one clause
      ((symbolp x) (symbol-value x)))

Often we want to execute the last clause whenever none of the previous clauses was successful. To do this, we use t as the condition of the last clause, like this: (t BODY-FORMS). The form t evaluates to t, which is never nil, so this clause never fails, provided the cond gets to it at all. For example:

(setq a 5)
(cond ((eq a 'hack) 'foo)
      (t "default"))
=> "default"

This cond expression returns foo if the value of a is hack, and returns the string "default" otherwise. Any conditional construct can be expressed with cond or with if. Therefore, the choice between them is a matter of style. For example:

(if A B C)
≡
(cond (A B) (t C))

It can be convenient to bind variables in conjunction with using a conditional. It's often the case that you compute a value, and then want to do something with that value if it's non-nil. The straightforward way to do that is to just write, for instance:

(let ((result1 (do-computation)))
  (when result1
    (let ((result2 (do-more result1)))
      (when result2
        (do-something result2)))))

Since this is a very common pattern, Emacs provides a number of macros to make this easier and more readable. The above can be written the following way instead:

(when-let* ((result1 (do-computation))
            (result2 (do-more result1)))
  (do-something result2))

There's a number of variations on this theme, and they're described below.

if-let*

Evaluate each binding in varlist, stopping if a binding value is nil. If all are non-nil, return the value of then-form, otherwise the last form in else-forms. Each element of varlist has the form (SYMBOL VALUE-FORM): value-form is evaluated and symbol is locally bound to the result. Bindings are sequential, as in let* (Local Variables). If only the test result of value-form is of interest, use _ for symbol. Then value-form is evaluated and checked for nil, but its value is not bound. As a special case, an entry of varlist may be of the form just SYMBOL, which means to check the current binding of symbol for nil.

when-let*

Evaluate each binding in varlist, stopping if a binding value is nil. If all are non-nil, return the value of the last form in then-forms. varlist has the same form as in if-let*: Each element of varlist has the form (SYMBOL VALUE-FORM), in which value-form is evaluated and symbol is locally bound to the result. Bindings are sequential, as in let* (Local Variables). If only the test result of value-form is of interest, use _ for symbol. Then value-form is evaluated and checked for nil, but its value is not bound. As a special case, an entry of varlist may be of the form just SYMBOL, which means to check the current binding of symbol for nil.

and-let*

Evaluate each binding in varlist, stopping if a binding value is nil. If all are non-nil, return the value of the last form in then-forms, or, if there are no then-forms, return the value of the last binding. varlist has the same form as in if-let*: Each element of varlist has the form (SYMBOL VALUE-FORM), in which value-form is evaluated and symbol is locally bound to the result. Bindings are sequential, as in let* (Local Variables). If only the test result of value-form is of interest, use _ for symbol. Then value-form is evaluated and checked for nil, but its value is not bound. As a special case, an entry of varlist may be of the form just SYMBOL, which means to check the current binding of symbol for nil.

Some Lisp programmers follow the convention that and and and-let* are for forms evaluated for return value, and when and when-let* are for forms evaluated for side-effect with returned values ignored. As a matter of style, it is best not to use these macros to bind values that will always be non-nil. For example, suppose that foo-p and bar-p might return nil, and the code should not proceed in that case. Instead of

(when-let* ((foo-val (foo-p))
            (num (+ 2 foo-val))
            (bar-val (bar-p num)))
  ...)

consider using

(when-let* ((foo-val (foo-p)))
  (let ((num (+ 2 foo-val))
    (when-let* ((bar-val (bar-p num)))
      ...)))

because this makes it clearer that the execution of the code is conditional on foo-val and bar-val being non-nil, but not directly conditional on num, which moreover can never be nil. There is no cond-let* macro because extending the structure shared by if-let*, when-let* and and-let* to the case of cond is not simple.(The problem is that there are multiple ways to do it that are all useful but not compatible. In addition) However, you can use the cond* macro's bind-and* clauses (cond* Macro) to achieve something similar:

(cond* ((bind-and* (result1 (do-computation))
                   (result2 (do-more result1)))
        (do-something result2))
       ...)

A similar macro exists to run a loop until one binding evaluates to nil:

while-let

Evaluate each binding in spec in turn, stopping if a binding value is nil. If all are non-nil, execute then-forms, then repeat the loop. Note that when the loop is repeated, the value-forms in spec are re-evaluated and the bindings are established anew. varlist has the same form as in if-let*: Each element of varlist has the form (SYMBOL VALUE-FORM), in which value-form is evaluated and symbol is locally bound to the result. Bindings are sequential, as in let* (Local Variables). If only the test result of value-form is of interest, use _ for symbol. Then value-form is evaluated and checked for nil, but its value is not bound. As a special case, an entry of varlist may be of the form just SYMBOL, which means to check the current binding of symbol for nil. The return value of while-let is always nil.

This section describes constructs that are often used together with if and cond to express complicated conditions. The constructs and and or can also be used individually as kinds of multiple conditional constructs.

not

This function tests for the falsehood of condition. It returns t if condition is nil, and nil otherwise. The function not is identical to null, and we recommend using the name null if you are testing for an empty list or nil value.

and

The and special form tests whether all the conditions are true. It works by evaluating the conditions one by one in the order written. If any of the conditions evaluates to nil, then the result of the and must be nil regardless of the remaining conditions; so and returns nil right away, ignoring the remaining conditions. If all the conditions turn out non-nil, then the value of the last of them becomes the value of the and form. Just (and), with no conditions, returns t, appropriate because all the conditions turned out non-nil. (Think about it; which one did not?) Here is an example. The first condition returns the integer 1, which is not nil. Similarly, the second condition returns the integer 2, which is not nil. The third condition is nil, so the remaining condition is never evaluated.

(and (print 1) (print 2) nil (print 3))
     -| 1
     -| 2
=> nil

Here is a more realistic example of using and:

(if (and (consp foo) (eq (car foo) 'x))
    (message "foo is a list starting with x"))

Note that (car foo) is not executed if (consp foo) returns nil, thus avoiding an error. and expressions can also be written using either if or cond. Here's how:

(and ARG1 ARG2 ARG3)
≡
(if ARG1 (if ARG2 ARG3))
≡
(cond (ARG1 (cond (ARG2 ARG3))))

or

The or special form tests whether at least one of the conditions is true. It works by evaluating all the conditions one by one in the order written. If any of the conditions evaluates to a non-nil value, then the result of the or must be non-nil; so or returns right away, ignoring the remaining conditions. The value it returns is the non-nil value of the condition just evaluated. If all the conditions turn out nil, then the or expression returns nil. Just (or), with no conditions, returns nil, appropriate because all the conditions turned out nil. (Think about it; which one did not?) For example, this expression tests whether x is either nil or the integer zero:

(or (eq x nil) (eq x 0))

Like the and construct, or can be written in terms of cond. For example:

(or ARG1 ARG2 ARG3)
≡
(cond (ARG1)
      (ARG2)
      (ARG3))

You could almost write or in terms of if, but not quite:

(if ARG1 ARG1
  (if ARG2 ARG2
    ARG3))

This is not completely equivalent because it can evaluate arg1 or arg2 twice. By contrast, (or ARG1 ARG2 ARG3) never evaluates any argument more than once.

xor

This function returns the boolean exclusive-or of condition1 and condition2. That is, xor returns nil if either both arguments are nil, or both are non-nil. Otherwise, it returns the value of that argument which is non-nil. Note that in contrast to or, both arguments are always evaluated.

Aside from the four basic conditional forms, Emacs Lisp also has a pattern-matching conditional form, the pcase macro, a hybrid of cond and cl-case (Conditionals) that overcomes their limitations and introduces the pattern matching programming style. The limitations that pcase overcomes are:

• The cond form chooses among alternatives by evaluating the predicate condition of each of its clauses (Conditionals). The primary limitation is that variables let-bound in condition are not available to the clause's body-forms. Another annoyance (more an inconvenience than a limitation) is that when a series of condition predicates implement equality tests, there is a lot of repeated code. (cl-case solves this inconvenience.)
• The cl-case macro chooses among alternatives by evaluating the equality of its first argument against a set of specific values. Its limitations are two-fold:
• The equality tests use eql.
• The values must be known and written in advance. These render cl-case unsuitable for strings or compound data structures (e.g., lists or vectors). (cond doesn't have these limitations, but it has others, see above.)

Conceptually, the pcase macro borrows the first-arg focus of cl-case and the clause-processing flow of cond, replacing condition with a generalization of the equality test which is a variant of pattern matching, and adding facilities so that you can concisely express a clause's predicate, and arrange to share let-bindings between a clause's predicate and body-forms. The concise expression of a predicate is known as a pattern. When the predicate, called on the value of the first arg, returns non-nil, we say that "the pattern matches the value" (or sometimes "the value matches the pattern").

Here's an example that highlights some advantages pcase has over cl-case (Conditionals).

(pcase (get-return-code x)
  ;; string
  ((and (pred stringp) msg)
   (message "%s" msg))
  ;; symbol
  ('success       (message "Done!"))
  ('would-block   (message "Sorry, can't do it now"))
  ('read-only     (message "The schmilblick is read-only"))
  ('access-denied (message "You do not have the needed rights"))
  ;; default
  (code           (message "Unknown return code %S" code)))

With cl-case, you would need to explicitly declare a local variable code to hold the return value of get-return-code. Also cl-case is difficult to use with strings because it uses eql for comparison.

A common idiom is to write a pattern starting with and, with one or more symbol sub-patterns providing bindings to the sub-patterns that follow (as well as to the body forms). For example, the following pattern matches single-digit integers.

(and
  (pred integerp)
  n                     ; bind n to EXPVAL
  (guard (<= -9 n 9)))

First, pred matches if (integerp EXPVAL) evaluates to non-nil. Next, n is a symbol pattern that matches anything and binds n to expval. Lastly, guard matches if the boolean expression (< -9 n 9)= (note the reference to n) evaluates to non-nil. If all these sub-patterns match, and matches.

Here is another example that shows how to reformulate a simple matching task from its traditional implementation (function grok/traditional) to one using pcase (function grok/pcase). The docstring for both these functions is: "If OBJ is a string of the form "key:NUMBER", return NUMBER (a string). Otherwise, return the list ("149" default)." First, the traditional implementation (Regular Expressions):

(defun grok/traditional (obj)
  (if (and (stringp obj)
           (string-match "^key:\\([[:digit:]]+\\)$" obj))
      (match-string 1 obj)
    (list "149" 'default)))

(grok/traditional "key:0")   => "0"
(grok/traditional "key:149") => "149"
(grok/traditional 'monolith) => ("149" default)

The reformulation demonstrates symbol binding as well as or, and, pred, app and let.

(defun grok/pcase (obj)
  (pcase obj
    ((or                                     ; line 1
      (and                                   ; line 2
       (pred stringp)                        ; line 3
       (pred (string-match                   ; line 4
              "^key:\\([[:digit:]]+\\)$"))   ; line 5
       (app (match-string 1)                 ; line 6
            val))                            ; line 7
      (let val (list "149" 'default)))       ; line 8
     val)))                                  ; line 9

(grok/pcase "key:0")   => "0"
(grok/pcase "key:149") => "149"
(grok/pcase 'monolith) => ("149" default)

The bulk of grok/pcase is a single clause of a pcase form, the pattern on lines 1-8, the (single) body form on line 9. The pattern is or, which tries to match in turn its argument sub-patterns, first and (lines 2-7), then let (line 8), until one of them succeeds. As in the previous example (Example 1), and begins with a pred sub-pattern to ensure the following sub-patterns work with an object of the correct type (string, in this case). If (stringp EXPVAL) returns nil, pred fails, and thus and fails, too. The next pred (lines 4-5) evaluates (string-match RX EXPVAL) and matches if the result is non-nil, which means that expval has the desired form: key:NUMBER. Again, failing this, pred fails and and, too. Lastly (in this series of and sub-patterns), app evaluates (match-string 1 EXPVAL) (line 6) to get a temporary value tmp (i.e., the "NUMBER" substring) and tries to match tmp against pattern val (line 7). Since that is a symbol pattern, it matches unconditionally and additionally binds val to tmp. Now that app has matched, all and sub-patterns have matched, and so and matches. Likewise, once and has matched, or matches and does not proceed to try sub-pattern let (line 8). Let's consider the situation where obj is not a string, or it is a string but has the wrong form. In this case, one of the pred (lines 3-5) fails to match, thus and (line 2) fails to match, thus or (line 1) proceeds to try sub-pattern let (line 8). First, let evaluates (list "149" 'default) to get ("149" default), the exprval, and then tries to match exprval against pattern val. Since that is a symbol pattern, it matches unconditionally and additionally binds val to exprval. Now that let has matched, or matches. Note how both and and let sub-patterns finish in the same way: by trying (always successfully) to match against the symbol pattern val, in the process binding val. Thus, or always matches and control always passes to the body form (line 9). Because that is the last body form in a successfully matched pcase clause, it is the value of pcase and likewise the return value of grok/pcase (What Is a Function).

The preceding examples all use sequencing patterns which include the symbol sub-pattern in some way. Here are some important details about that usage.

1. When symbol occurs more than once in seqpat, the second and subsequent occurrences do not expand to re-binding, but instead expand to an equality test using eq. The following example features a pcase form with two clauses and two seqpat, A and B. Both A and B first check that expval is a pair (using pred), and then bind symbols to the car and cdr of expval (using one app each). For A, because symbol st is mentioned twice, the second mention becomes an equality test using eq. On the other hand, B uses two separate symbols, s1 and s2, both of which become independent bindings. (defun grok (object) (pcase object ((and (pred consp) ; seqpat A (app car st) ; first mention: st (app cdr st)) ; second mention: st (list 'eq st)) ((and (pred consp) ; seqpat B (app car s1) ; first mention: s1 (app cdr s2)) ; first mention: s2 (list 'not-eq s1 s2)))) (let ((s "yow!")) (grok (cons s s))) => (eq "yow!") (grok (cons "yo!" "yo!")) => (not-eq "yo!" "yo!") (grok '(4 2)) => (not-eq 4 (2))
2. Side-effecting code referencing symbol is undefined. Avoid. For example, here are two similar functions. Both use and, symbol and guard: (defun square-double-digit-p/CLEAN (integer) (pcase (* integer integer) ((and n (guard (< 9 n 100))) (list 'yes n)) (sorry (list 'no sorry)))) (square-double-digit-p/CLEAN 9) > (yes 81) (square-double-digit-p/CLEAN 3) => (no 9) (defun square-double-digit-p/MAYBE (integer) (pcase (* integer integer) ((and n (guard (< 9 (incf n) 100))) (list 'yes n)) (sorry (list 'no sorry)))) (square-double-digit-p/MAYBE 9) => (yes 81) (square-double-digit-p/MAYBE 3) => (yes 9) ; WRONG! The difference is in /boolean-expression/ in =guard: CLEAN references n simply and directly, while MAYBE references n with a side-effect, in the expression (incf n). When integer is 3, here's what happens:
3. The first n binds it to expval, i.e., the result of evaluating (* 3 3), or 9.
4. boolean-expression is evaluated: start: (< 9 (incf n) 100) becomes: (< 9 (setq n (1+ n)) 100) becomes: (< 9 (setq n (1+ 9)) 100) becomes: (< 9 (setq n 10) 100) ; side-effect here! becomes: (< 9 n 100) ; n now bound to 10 becomes: (< 9 10 100) becomes: t
5. Because the result of the evaluation is non-nil, guard matches, and matches, and control passes to that clause's body forms. Aside from the mathematical incorrectness of asserting that 9 is a double-digit integer, there is another problem with MAYBE. The body form references n once more, yet we do not see the updated value—10—at all. What happened to it? To sum up, it's best to avoid side-effecting references to symbol patterns entirely, not only in boolean-expression (in guard), but also in expr (in let) and function (in pred and app).
6. On match, the clause's body forms can reference the set of symbols the pattern let-binds. When seqpat is and, this set is the union of all the symbols each of its sub-patterns let-binds. This makes sense because, for and to match, all the sub-patterns must match. When seqpat is or, things are different: or matches at the first sub-pattern that matches; the rest of the sub-patterns are ignored. It makes no sense for each sub-pattern to let-bind a different set of symbols because the body forms have no way to distinguish which sub-pattern matched and choose among the different sets. For example, the following is invalid: (require 'cl-lib) (pcase (read-number "Enter an integer: ") ((or (and (pred cl-evenp) e-num) ; bind e-num to expval o-num) ; bind o-num to expval (list e-num o-num))) Enter an integer: 42 error–> Symbol's value as variable is void: o-num Enter an integer: 149 error–> Symbol's value as variable is void: e-num Evaluating body form (list e-num o-num) signals error. To distinguish between sub-patterns, you can use another symbol, identical in name in all sub-patterns but differing in value. Reworking the above example: (require 'cl-lib) (pcase (read-number "Enter an integer: ") ((and num ; line 1 (or (and (pred cl-evenp) ; line 2 (let spin 'even)) ; line 3 (let spin 'odd))) ; line 4 (list spin num))) ; line 5 Enter an integer: 42 > (even 42) Enter an integer: 149 => (odd 149) Line 1 "factors out" the /expval/ binding with =and and symbol (in this case, num). On line 2, or begins in the same way as before, but instead of binding different symbols, uses let twice (lines 3-4) to bind the same symbol spin in both sub-patterns. The value of spin distinguishes the sub-patterns. The body form references both symbols (line 5).

(pcase-defmacro less-than (n)
  "Matches if EXPVAL is a number less than N."
  `(pred (> ,n)))

(pcase-defmacro integer-less-than (n)
  "Matches if EXPVAL is an integer less than N."
  `(and (pred integerp)
        (less-than ,n)))

(and (pred listp)
     ls
     (guard (= 2 (length ls)))
     (guard (string= "first" (car ls)))
     (let second-elem (cadr ls)))

`("first" ,second-elem)

(defun evaluate (form env)
  (pcase form
    (`(add ,x ,y)       (+ (evaluate x env)
                           (evaluate y env)))
    (`(call ,fun ,arg)  (funcall (evaluate fun env)
                                 (evaluate arg env)))
    (`(fn ,arg ,body)   (lambda (val)
                          (evaluate body (cons (cons arg val)
                                               env))))
    ((pred numberp)     form)
    ((pred symbolp)     (cdr (assq form env)))
    (_                  (error "Syntax error: %S" form))))

(evaluate '(add 1 2) nil)                 => 3
(evaluate '(add x y) '((x . 1) (y . 2)))  => 3
(evaluate '(call (fn x (add 1 x)) 2) nil) => 3
(evaluate '(sub 1 2) nil)                 => error

(pcase my-list
    (`(add ,x ,y)  (message "Contains %S and %S" x y)))

(pcase-let ((`(add ,x ,y) my-list))
    (message "Contains %S and %S" x y))

(pcase-let ((`(,major ,minor)
	     (split-string "image/png" "/")))
  minor)
     => "png"

(setq fun
      (pcase-lambda (`(,key . ,val))
        (vector key (* val 10))))
(funcall fun '(foo . 2))
    => [foo 20]

Iteration means executing part of a program repetitively. For example, you might want to repeat some computation once for each element of a list, or once for each integer from 0 to n. You can do this in Emacs Lisp with the special form while:

while

while first evaluates condition. If the result is non-nil, it evaluates forms in textual order. Then it reevaluates condition, and if the result is non-nil, it evaluates forms again. This process repeats until condition evaluates to nil. There is no limit on the number of iterations that may occur. The loop will continue until either condition evaluates to nil or until an error or throw jumps out of it (Nonlocal Exits). The value of a while form is always nil.

(setq num 0)
     => 0
(while (< num 4)
  (princ (format "Iteration %d." num))
  (setq num (1+ num)))
     -| Iteration 0.
     -| Iteration 1.
     -| Iteration 2.
     -| Iteration 3.
     => nil

To write a repeat-until loop, which will execute something on each iteration and then do the end-test, put the body followed by the end-test in a progn as the first argument of while, as shown here:

(while (progn
         (forward-line 1)
         (not (looking-at "^$"))))

This moves forward one line and continues moving by lines until it reaches an empty line. It is peculiar in that the while has no body, just the end test (which also does the real work of moving point). The dolist and dotimes macros provide convenient ways to write two common kinds of loops.

dolist

This construct executes body once for each element of list, binding the variable var locally to hold the current element. Then it returns the value of evaluating result, or nil if result is omitted. For example, here is how you could use dolist to define the reverse function:

(defun reverse (list)
  (let (value)
    (dolist (elt list value)
      (setq value (cons elt value)))))

dotimes

This construct executes body once for each integer from 0 (inclusive) to count (exclusive), binding the variable var to the integer for the current iteration. Then it returns the value of evaluating result, or nil if result is omitted. Use of result is deprecated. Here is an example of using dotimes to do something 100 times:

(dotimes (i 100)
  (insert "I will not obey absurd orders\n"))

A generator is a function that produces a potentially-infinite stream of values. Each time the function produces a value, it suspends itself and waits for a caller to request the next value.

iter-defun

iter-defun defines a generator function. A generator function has the same signature as a normal function, but works differently. Instead of executing body when called, a generator function returns an iterator object. That iterator runs body to generate values, emitting a value and pausing where iter-yield or iter-yield-from appears. When body returns normally, iter-next signals iter-end-of-sequence with body's result as its condition data. Any kind of Lisp code is valid inside body, but iter-yield and iter-yield-from cannot appear inside unwind-protect forms.

iter-lambda

iter-lambda produces an unnamed generator function that works just like a generator function produced with iter-defun.

iter-yield

When it appears inside a generator function, iter-yield indicates that the current iterator should pause and return value from iter-next. iter-yield evaluates to the value parameter of next call to iter-next.

iter-yield-from

iter-yield-from yields all the values that iterator produces and evaluates to the value that iterator's generator function returns normally. While it has control, iterator receives values sent to the iterator using iter-next.

To use a generator function, first call it normally, producing a iterator object. An iterator is a specific instance of a generator. Then use iter-next to retrieve values from this iterator. When there are no more values to pull from an iterator, iter-next raises an iter-end-of-sequence condition with the iterator's final value. It's important to note that generator function bodies only execute inside calls to iter-next. A call to a function defined with iter-defun produces an iterator; you must drive this iterator with iter-next for anything interesting to happen. Each call to a generator function produces a different iterator, each with its own state.

iter-next

Retrieve the next value from iterator. If there are no more values to be generated (because iterator's generator function returned), iter-next signals the iter-end-of-sequence condition; the data value associated with this condition is the value with which iterator's generator function returned. value is sent into the iterator and becomes the value to which iter-yield evaluates. value is ignored for the first iter-next call to a given iterator, since at the start of iterator's generator function, the generator function is not evaluating any iter-yield form.

iter-close

If iterator is suspended inside an unwind-protect's bodyform and becomes unreachable, Emacs will eventually run unwind handlers after a garbage collection pass. (Note that iter-yield is illegal inside an unwind-protect's unwindforms.) To ensure that these handlers are run before then, use iter-close.

Some convenience functions are provided to make working with iterators easier:

iter-do

Run body with var bound to each value that iterator produces.

The Common Lisp loop facility also contains features for working with iterators. Loop Facility. The following piece of code demonstrates some important principles of working with iterators.

(require 'generator)
(iter-defun my-iter (x)
  (iter-yield (1+ (iter-yield (1+ x))))
   ;; Return normally
  -1)

(let* ((iter (my-iter 5))
       (iter2 (my-iter 0)))
  ;; Prints 6
  (print (iter-next iter))
  ;; Prints 9
  (print (iter-next iter 8))
  ;; Prints 1; iter and iter2 have distinct states
  (print (iter-next iter2 nil))

  ;; We expect the iter sequence to end now
  (condition-case x
      (iter-next iter)
    (iter-end-of-sequence
      ;; Prints -1, which my-iter returned normally
      (print (cdr x)))))

A nonlocal exit is a transfer of control from one point in a program to another remote point. Nonlocal exits can occur in Emacs Lisp as a result of errors; you can also use them under explicit control. Nonlocal exits unbind all variable bindings made by the constructs being exited.

(defun foo-outer ()
  (catch 'foo
    (foo-inner)))

(defun foo-inner ()
  ...
  (if x
      (throw 'foo t))
  ...)

(defun search-foo ()
  (catch 'loop
    (let ((i 0))
      (while (< i 10)
        (let ((j 0))
          (while (< j 10)
            (if (foo i j)
                (throw 'loop (list i j)))
            (setq j (1+ j))))
        (setq i (1+ i))))))

(defun catch2 (tag)
  (catch tag
    (throw 'hack 'yes)))
=> catch2

(catch 'hack
  (print (catch2 'hack))
  'no)
-| yes
=> no

(catch 'hack
  (print (catch2 'quux))
  'no)
=> yes

(error "That is an error -- try something else")
     error--> That is an error -- try something else

(error "Invalid name `%s'" "A%%B")
     error--> Invalid name `A%%B'

(signal 'wrong-number-of-arguments '(x y))
     error--> Wrong number of arguments: x, y

(signal 'no-such-error '("My unknown error condition"))
     error--> peculiar error: "My unknown error condition"

(condition-case nil
    (delete-file filename)
  (error nil))

(condition-case nil
    (delete-file filename)
  ((debug error) nil))

(error nil)

(arith-error (message "Division by zero"))

((arith-error file-error)
 (message
  "Either division by zero or failure to open a file"))

(signal err)

(defun safe-divide (dividend divisor)
  (condition-case err
      ;; Protected form.
      (/ dividend divisor)
    ;; The handler.
    (arith-error                        ; Condition.
     ;; Display the usual message for this error.
     (message "%s" (error-message-string err))
     1000000)))
=> safe-divide

(safe-divide 5 0)
     -| Arithmetic error: (arith-error)
=> 1000000

(safe-divide nil 3)
     error--> Wrong type argument: number-or-marker-p, nil

(setq baz 34)
     => 34

(condition-case err
    (if (eq baz 35)
        t
      ;; This is a call to the function error.
      (error "Rats!  The variable %s was %s, not 35" 'baz baz))
  ;; This is the handler; it is not a form.
  (error (princ (format "The error was: %s" err))
         2))
-| The error was: (error "Rats!  The variable baz was 34, not 35")
=> 2

(ignore-errors
   (delete-file filename))

(ignore-error end-of-file
    (read ""))

(handler-bind
    ((error
      (lambda (err)
        (push (cons err (current-buffer)) my-log-of-errors))))
  BODY-FORMS...)

(handler-bind
    ((user-error
      (lambda (err)
        (signal 'error (cdr err)))))
  BODY-FORMS...)

(condition-case err
    (progn BODY-FORMS...)
  (user-error (signal 'error (cdr err))))

Debugger entered--Lisp error: (error "Oops")
  signal(error ("Oops"))
  #f(lambda (err) [t] (signal 'error (cdr err)))((user-error "Oops"))
  user-error("Oops")
  ...
  eval((handler-bind ((user-error (lambda (err) ...

(define-error 'new-error "A new error" 'my-own-errors)

(signal 'new-error '(x y))
     error--> A new error: x, y

(condition-case foo
    (bar nil t)
  (my-own-errors nil))

(let ((buffer (get-buffer-create " *temp*")))
  (with-current-buffer buffer
    (unwind-protect
        BODY-FORM
      (kill-buffer buffer))))

(let ((win nil))
  (unwind-protect
      (progn
        (setq process (ftp-setup-buffer host file))
        (if (setq win (ftp-login process host user password))
            (message "Logged in")
          (error "Ftp login failed")))
    (or win (and process (delete-process process)))))

There will be times when you want certain code to be compiled only when a certain condition holds. This is particularly the case when maintaining Emacs packages; to keep the package compatible with older versions of Emacs you may need to use a function or variable which has become obsolete in the current version of Emacs. You could just use a conditional form to select the old or new form at run time, but this tends to output annoying warning messages about the obsolete function/variable. For such situations, the macro static-if comes in handy. It is patterned after the special form if (Conditionals). To use this facility for an older version of Emacs, copy the source for static-if from the Emacs source file lisp/subr.el into your package.

static-if

Test condition at macro-expansion time. If its value is non-nil, expand the macro to then-form, otherwise expand it to else-forms enclosed in a progn. else-forms may be empty.

static-when

Test condition at macro-expansion time. If its value is non-nil, expand the macro to evaluate all body forms sequentially and return the value of the last one, or nil if there are none.

static-unless

Test condition at macro-expansion time. If its value is nil, expand the macro to evaluate all body forms sequentially and return the value of the last one, or nil if there are none. Here is an example of its use from CC Mode, which prevents a defadvice form being compiled in newer versions of Emacs:

(static-if (boundp 'comment-line-break-function)
    (progn)
  (defvar c-inside-line-break-advice nil)
  (defadvice indent-new-comment-line (around c-line-break-advice
                                             activate preactivate)
    "Call `c-indent-new-comment-line' if in CC Mode."
    (if (or c-inside-line-break-advice
            (not c-buffer-is-cc-mode))
        ad-do-it
      (let ((c-inside-line-break-advice t))
        (c-indent-new-comment-line (ad-get-arg 0))))))