I confused to use ELSE in LOOP.
Anyone explain me why following code is wrong?
Also, is it right to use RETURN NIL when the ELSE doesn't
has any clause?

;----------------
(loop for i from 0 to 10
      when (evenp i)
           do (print i)
           when (= i 6)
                do (print 'BINGO!!)
           else
                return nil
      else
           do (print 'odd))

Sungwoo

(loop for i from 0 to 10
      when (evenp i)
           do (print i)
      when (= i 6)
           do (print 'BINGO!!)
      else
           return nil
  else
       do (print 'odd))

The second WHEN ends the first WHEN, so the second ELSE is dangling.

The body of a DO clause is just regular Lisp expressions, and it ends when
the first symbol is encountered.  You can't have a WHEN inside a DO; if you
want conditionals inside the DO clause, you have to use a regular (if ...)
invocation:

(loop for i from 0 to 10
      when (evenp i)
           do (print i)
              (if (= i 6)
                  (print 'BINGO!!)
                  (return nil))
      else
           do (print 'odd))

I like LOOP, but I have a general rule of thumb about it: the more complex
a LOOP gets, the less appropriate it is to use.  It's great for some simple
constructs that it automates, such as collecting results, but if you try to
do too many things with it at once you're likely to run into problems, and
you should go back to "normal" Lisp code.

My codes mixed two hierarchical LOOP and four hierarchical WHEN, so I was
struggling to solve it. I should change it as a easy way then...
Thanks alot. =)

Sungwoo

RETURN terminates the loop. If you didn't mean to terminate on the
first even number, use a dummy else branch.

As a matter of style, i suggest using IF instead of WHEN
if (err, when :-)) the ELSE branch is present.

So, your code would appear as

(loop for i from 0 to 10
    if (evenp i)
      do (print i)
      and if (= i 6)
            do (print 'BINGO!!)
          else do ()
    else
      do (print 'odd))

which gives

0
odd
2
odd
4
odd
6
bingo!!
odd
8
odd
10
odd
nil

However, I'd advise you to use the conditional keywords only in very
simple cases. When things get more complicated, use normal Lisp forms
instead:

(loop for i from 0 to 10 do
      (cond ((evenp i)
             (print i)
             (when (= i 6) (print 'bingo!!)))
            (T
             (print 'odd))))

Michael

Their purpose is primarily to control the execution of LOOP's value
accumulation clauses. At least it helps to think of them this
way. That is, LOOP's conditional execution clauses are _not_ to be
used as general control structures, substituting the regular lisp
control structures.

So my rule of thumb would be: Use LOOP's conditional execution clauses
only where you can't use the regular lisp control operators.

(My second rule of thumb concerning LOOP would be the negative of
Barry Margolin's: The more complex the looping, the more you need/want
to use LOOP.)

In general however, you need to factor out the loop termination
condition(s), you don't want them embedded deep in other
code. Applying this to your contrieved example you'd get something
like this (it still doesn't make sense):

  (loop for i from 0 to 10
     as terminate = (and (evenp i) (not (= i 6)))
     do (cond
          ((evenp i)
           (print i)
           (when (= i 6) (print 'bingo)))
          (t (print 'odd)))
     until terminate)

If you _really_ need to terminate your loop from deep within other
functional code, consider using RETURN-FROM or throwing a
condition. I'd expect this to be _very_ infrequently required, though.

Sungwoo

;-----------
(loop for i from 0 to stroke-index
      when (= (aref stroke-array-y i) (dialine-y1 (aref stroke-array-x i)))
          when (and (> (aref stroke-array-x i) max-inter-x)
                    (> (aref stroke-array-y i) max-inter-y))
              do (setf max-inter-x (aref stroke-array-x i)
                       max-inter-y (aref stroke-array-y i))
          else
              when (and (< (aref stroke-array-x i) min-inter-x)
                        (< (aref stroke-array-y i) min-inter-y))
                  do (setf min-inter-x (aref stroke-array-x i)
                           min-inter-y (aref stroke-array-y i))
              else
                  return nil
      else
          when (/= deno 0)
              do (setf Ua (/ numer1 deno) Ub (/ numer2 deno))
              when (and (<= 0 Ua 1) (<= 0 Ub 1) (/= x1 x3) (/= y1 y3))
                  do (setf temp-x (float (+ x1 (* Ua (- x2 x1))))
                           temp-y (float (+ y1 (* Ua (- y2 y1)))))
                  when (and (> temp-x max-inter-x) (> temp-y max-inter-y))
                      do (setf max-inter-x temp-x max-inter-y temp-y)
                  else
                      when (and (< temp-x min-inter-x) (< temp-y min-inter-y))
                          do (setf min-inter-x temp-x min-inter-y temp-y))

Sungwoo

So, with all those potential problems, my feeling is that if you have to
ask, it's probably better to use something other than LOOP.  Most other
parts of Lisp have relatively straightforward semantics, they nest in
obvious ways, and interactions are pretty clear (perhaps the only notable
exception is the interaction between all the different exiting mechanisms
like RETURN, UNWIND-PROTECT, and condition handlers -- it was very
difficult to get that right in the standard).

Michael

(defmacro nothing () 'nil)

  if ... do ... end

  From 6.1.6 Conditional Execution Clauses

The optional loop keyword end marks the end of the clause.  If this keyword
is not supplied, the next loop keyword marks the end.  The construct end
can be used to distinguish the scoping of compound clauses.

Sungwoo