Peter Siebel - Practical Common Lisp

for i from 1 to number-form

with a repeatclause like this:

repeat number-form

These clauses are identical in effect except the repeatclause doesn't create an explicit loop variable.

The forclauses for iterating over lists are much simpler than the arithmetic clauses. They support only two prepositional phrases, inand on.

A phrase of this form:

for var in list-form

steps var over all the elements of the list produced by evaluating list-form .

(loop for i in (list 10 20 30 40) collect i) ==> (10 20 30 40)

Occasionally this clause is supplemented with a byphrase, which specifies a function to use to move down the list. The default is CDR but can be any function that takes a list and returns a sublist. For instance, you could collect every other element of a list with a loop like this:

(loop for i in (list 10 20 30 40) by #'cddr collect i) ==> (10 30)

An onprepositional phrase is used to step var over the cons cells that make up a list.

(loop for x on (list 10 20 30) collect x) ==> ((10 20 30) (20 30) (30))

This phrase too can take a bypreposition:

(loop for x on (list 10 20 30 40) by #'cddr collect x) ==> ((10 20 30 40) (30 40))

Looping over the elements of a vector (which includes strings and bit vectors) is similar to looping over the elements of a list except the preposition acrossis used instead of in. [236] You may wonder why LOOP can't figure out whether it's looping over a list or a vector without needing different prepositions. This is another consequence of LOOP being a macro: the value of the list or vector won't be known until runtime, but LOOP , as a macro, has to generate code at compile time. And LOOP 's designers wanted it to generate extremely efficient code. To be able to generate efficient code for looping across, say, a vector, it needs to know at compile time that the value will be a vector at runtime—thus, the different prepositions are needed. For instance:

(loop for x across "abcd" collect x) ==> (#\a #\b #\c #\d)

Iterating over a hash table or package is slightly more complicated because hash tables and packages have different sets of values you might want to iterate over—the keys or values in a hash table and the different kinds of symbols in a package. Both kinds of iteration follow the same pattern. The basic pattern looks like this:

(loop for var being the things in hash-or-package ...)

For hash tables, the possible values for things are hash-keysand hash-values, which cause varto be bound to successive values of either the keys or the values of the hash table. The hash-or-package form is evaluated once to produce a value, which must be a hash table.

To iterate over a package, things can be symbols, present-symbols, and external-symbols, which cause var to be bound to each of the symbols accessible in a package, each of the symbols present in a package (in other words, interned or imported into that package), or each of the symbols that have been exported from the package. The hash-or-package form is evaluated to produce the name of a package, which is looked up as if by FIND-PACKAGE or a package object. Synonyms are also available for parts of the forclause. In place of the, you can use each; you can use ofinstead of in; and you can write the things in the singular (for example, hash-keyor symbol).

Finally, since you'll often want both the keys and the values when iterating over a hash table, the hash table clauses support a usingsubclause at the end of the hash table clause.

(loop for k being the hash-keys in h using (hash-value v) ...)

(loop for v being the hash-values in h using (hash-key k) ...)

Both of these loops will bind kto each key in the hash table and vto the corresponding value. Note that the first element of the usingsubclause must be in the singular form. [237] Don't ask me why LOOP 's authors chickened out on the no-parentheses style for the using subclause.

If none of the other forclauses supports exactly the form of variable stepping you need, you can take complete control over stepping with an equals-then clause. This clause is similar to the binding clauses in a DO loop but cast in a more Algolish syntax. The template is as follows:

(loop for var = initial-value-form [ then step-form ] ...)

As usual, var is the name of the variable to be stepped. Its initial value is obtained by evaluating initial-value-form once before the first iteration. In each subsequent iteration, step-form is evaluated, and its value becomes the new value of var . With no thenpart to the clause, the initial-value-form is reevaluated on each iteration to provide the new value. Note that this is different from a DO binding clause with no step form.

The step-form can refer to other loop variables, including variables created by other forclauses later in the loop. For instance:

(loop repeat 5

for x = 0 then y

for y = 1 then (+ x y)

collect y) ==> (1 2 4 8 16)

However, note that each forclause is evaluated separately in the order it appears. So in the previous loop, on the second iteration xis set to the value of ybefore ychanges (in other words, 1). But yis then set to the sum of its old value (still 1) and the new value of x. If the order of the forclauses is reversed, the results change.

(loop repeat 5

for y = 1 then (+ x y)

for x = 0 then y

collect y) ==> (1 1 2 4 8)

Often, however, you'll want the step forms for multiple variables to be evaluated before any of the variables is given its new value (similar to how DO steps its variables). In that case, you can join multiple forclauses by replacing all but the first forwith and. You saw this formulation already in the LOOP version of the Fibonacci computation in Chapter 7. Here's another variant, based on the two previous examples:

(loop repeat 5

for x = 0 then y

and y = 1 then (+ x y)

collect y) ==> (1 1 2 3 5)

While the main variables needed within a loop are usually declared implicitly in forclauses, sometimes you'll need auxiliary variables, which you can declare with withclauses.

with var [ = value-form ]

The name var becomes the name of a local variable that will cease to exist when the loop finishes. If the withclause contains an = value-formpart, the variable will be initialized, before the first iteration of the loop, to the value of value-form .