Common Lisp the Language, 2nd Edition

26.10. Conditional Execution

The loop keywords if, when, and unless designate constructs that are useful when you want some loop clauses to operate under a specified condition.

If the specified condition is true, the succeeding loop clause is executed. If the specified condition is not true, the succeeding clause is skipped, and program control moves to the clause that follows the loop keyword else. If the specified condition is not true and no else clause is specified, the entire conditional construct is skipped. Several clauses can be connected into one compound clause with the loop keyword and. The end of the conditional clause can be marked with the keyword end.

[Loop Clause]

if expr clause {and clause}*
   [else clause {and clause}*] [end] 
when expr clause {and clause}*
   [else clause {and clause}*] [end] 
unless expr clause {and clause}*
   [else clause {and clause}*] [end]

The constructs when and if allow conditional execution of loop clauses. These constructs are synonyms and can be used interchangeably. [Compare this to the macro when, which does not allow an ``else'' part.-GLS]

If the value of the test expression expr is non-nil, the expression clause1 is evaluated. If the test expression evaluates to nil and an else construct is specified, the statements that follow the else are evaluated; otherwise, control passes to the next clause.

The unless construct is equivalent to when (not expr) and if (not expr). If the value of the test expression expr is nil, the expression clause1 is evaluated. If the test expression evaluates to non-nil and an else construct is specified, the statements that follow the else are evaluated; otherwise, control passes to the next clause. [Compare this to the macro unless, which does not allow an ``else'' part-or do I mean a ``then'' part?! Ugh. To prevent confusion, I strongly recommend as a matter of style that else not be used with unless loop clauses.-GLS]

The clause arguments must be either accumulation, unconditional, or conditional clauses (see section 26.3.2). Clauses that follow the test expression can be grouped by using the loop keyword and to produce a compound clause.

The loop keyword it can be used to refer to the result of the test expression in a clause. If multiple clauses are connected with and, the it construct must be used in the first clause in the block. Since it is a loop keyword, it may not be used as a local variable within a loop.

If when or if clauses are nested, each else is paired with the closest preceding when or if construct that has no associated else.

The optional loop keyword end marks the end of the clause. If this keyword is not specified, the next loop keyword marks the end. You can use end to distinguish the scoping of compound clauses.

;;; Group conditional clauses into a block. 
(loop for i in numbers-list 
      when (oddp i) 
        do (print i) 
        and collect i into odd-numbers 
        and do (terpri) 
      else     ;I is even 
        collect i into even-numbers 
      finally 
        (return (values odd-numbers even-numbers)))

;;; Collect numbers larger than 3. 
(loop for i in '(1 2 3 4 5 6) 
      when (and (> i 3) i) 
      collect it)     ;it refers to (and (> i 3) i) 
   => (4 5 6)

;;; Find a number in a list. 
(loop for i in '(1 2 3 4 5 6) 
      when (and (> i 3) i) 
      return it) 
   => 4

;;; The preceding example is similar to the following one. 
(loop for i in '(1 2 3 4 5 6) 
      thereis (and (> i 3) i)) 
   => 4

;;; An example of using UNLESS with ELSE (yuk).`-GLS 
(loop for turtle in teenage-mutant-ninja-turtles do
  (loop for x in '(joker brainiac shredder krazy-kat) 
        unless (evil x) 
          do (eat (make-pizza :anchovies t)) 
        else unless (and (eq x 'shredder) (attacking-p x))
               do (cut turtle slack);When the evil Shredder attacks, 
             else (fight turtle x)));those turtle boys don't cut no slack

;;; Nest conditional clauses. 
(loop for i in list 
      when (numberp i) 
        when (bignump i) 
          collect i into big-numbers 
        else     ;Not (bignump i) 
          collect i into other-numbers 
      else     ;Not (numberp i) 
        when (symbolp i)  
          collect i into symbol-list 
        else     ;Not (symbolp i) 
          (error "found a funny value in list ~S, value ~S~%" 
                "list i)) 

;;; Without the END marker, the last AND would apply to the 
;;; inner IF rather than the outer one. 
(loop for x from 0 to 3  
      do (print x) 
      if (zerop (mod x 2)) 
        do (princ " a") 
          and if (zerop (floor x 2)) 
                do (princ " b") 
              end 
          and do (princ " c"))