The “simple” loop form:
loop
{compound-form}* ⇒ {result}*
The “extended” loop form:
loop
[!name-clause]
{!variable-clause}*
{!main-clause}* ⇒ {result}*
name-clause ::=named
name
variable-clause ::=!with-clause | !initial-final | !for-as-clause
with-clause ::=with
var1 [type-spec] [= form1] {and
var2 [type-spec] [= form2]}*
main-clause ::=!unconditional | !accumulation | !conditional | !termination-test | !initial-final
initial-final ::=initially
{compound-form}^+ | finally
{compound-form}^+
unconditional ::={do
| doing
} {compound-form}^+ | return
{form | it
}
accumulation ::=!list-accumulation | !numeric-accumulation
list-accumulation ::={collect
| collecting
| append
| appending
| nconc
| nconcing
} {form | it
}
[into
simple-var]
numeric-accumulation ::={count
| counting
| sum
| summing
| } maximize
| maximizing
| minimize
| minimizing
{form | it
}
[into
simple-var] [type-spec]
conditional ::={if
| when
| unless
} form !selectable-clause {and
!selectable-clause}*
[else
!selectable-clause {and
!selectable-clause}*]
[end
]
selectable-clause ::=!unconditional | !accumulation | !conditional
termination-test ::=while
form | until
form | repeat
form | always
form | never
form | thereis
form
for-as-clause ::={for
| as
} !for-as-subclause {and
!for-as-subclause}*
for-as-subclause ::=!for-as-arithmetic | !for-as-in-list | !for-as-on-list | !for-as-equals-then | !for-as-across | !for-as-hash | !for-as-package
for-as-arithmetic ::=var [type-spec] !for-as-arithmetic-subclause
for-as-arithmetic-subclause ::=!arithmetic-up | !arithmetic-downto | !arithmetic-downfrom
arithmetic-up ::=[[{from
| upfrom
} form1 | {to
| upto
| below
} form2 | by
form3]]^+
arithmetic-downto ::=[[{from
form1}^1 | {{downto
| above
} form2}^1 | by
form3]]
arithmetic-downfrom ::=[[{downfrom
form1}^1 | {to
| downto
| above
} form2 | by
form3]]
for-as-in-list ::=var [type-spec] in
form1 [by
step-fun]
for-as-on-list ::=var [type-spec] on
form1 [by
step-fun]
for-as-equals-then ::=var [type-spec] = form1 [then
form2]
for-as-across ::=var [type-spec] across
vector
for-as-hash ::=var [type-spec] being
{each
| the
}
{{hash-key
| hash-keys
} {in
| of
} hash-table
[using
(hash-value
other-var)] |
{hash-value
| hash-values
} {in
| of
} hash-table
[using
(hash-key
other-var)]}
for-as-package ::=var [type-spec] being
{each
| the
}
{symbol
| symbols
|
present-symbol
| present-symbols
|
external-symbol
| external-symbols
}
[{in
| of
} package]
type-spec ::=!simple-type-spec | !destructured-type-spec
simple-type-spec ::=fixnum | float | t | nil
destructured-type-spec ::=of-type
d-type-spec
d-type-spec ::=type-specifier | (d-type-spec . d-type-spec)
var ::=!d-var-spec
var1 ::=!d-var-spec
var2 ::=!d-var-spec
other-var ::=!d-var-spec
d-var-spec ::=simple-var | nil | (!d-var-spec .
!d-var-spec)
compound-form—a compound form.
name—a symbol.
simple-var—a symbol (a variable name).
form, form1, form2, form3—a form.
step-fun—a form that evaluates to a function of one argument.
vector—a form that evaluates to a vector.
hash-table—a form that evaluates to a hash table.
package—a form that evaluates to a package designator.
type-specifier—a type specifier. This might be either an atomic type specifier or a compound type specifier, which introduces some additional complications to proper parsing in the face of destructuring; for further information, see Destructuring.
result—an object.
For details, see The LOOP Facility.
;; An example of the simple form of LOOP. (defun sqrt-advisor () (loop (format t "~&Number: ") (let ((n (parse-integer (read-line) :junk-allowed t))) (when (not n) (return)) (format t "~&The square root of ~D is ~D.~%" n (sqrt n))))) ⇒ SQRT-ADVISOR (sqrt-advisor)|>
Number: |>>5
<<|[<--~]
|>
The square root of 5 is 2.236068.|>
Number: |>>4
<<|[<--~]
|>
The square root of 4 is 2.|>
Number: |>>done
<<| ⇒ NIL ;; An example of the extended form of LOOP. (defun square-advisor () (loop as n = (progn (format t "~&Number: ") (parse-integer (read-line) :junk-allowed t)) while n do (format t "~&The square of ~D is ~D.~ ⇒ SQUARE-ADVISOR (square-advisor)[<--~]
|>
Number: |>>4
<<|[<--~]
|>
The square of 4 is 16.|>
Number: |>>23
<<|[<--~]
|>
The square of 23 is 529.|>
Number: |>>done
<<| ⇒ NIL ;; Another example of the extended form of LOOP. (loop for n from 1 to 10 when (oddp n) collect n) ⇒ (1 3 5 7 9)[<--~]
do, do* [Macro] , dolist [Macro] , dotimes [Macro] , return [Macro] , go [Special Operator] , throw [Special Operator] , Destructuring
Except that loop-finish cannot be used within a simple loop form, a simple loop form is related to an extended loop form in the following way:
(loop {compound-form}*) ≡ (loop do {compound-form}*)