Loop

Background

The Loop Macro is one of the most valuable, and least documented of the
operations in Common Lisp. It is valuable because it is more powerful, more
compact, and more readable than comparable Common Lisp constructs such as
mapping operations and recursion. It also uses a programming style that will be
familiar to programmers who have worked with other more traditional languages.
This short guide provides examples of how to use the Loop Macro.
The Loop macro is different than most Lisp expressions in having a complex
internal syntax that is more similar to programming languages like C or Pascal.
So you need to read Loop expressions with half of your brain in Lisp mode, and
the other half in Pascal mode.
Think of Loop expressions as having four parts: expressions that set up
variables that will be iterated, expressions that conditionally terminate the
iteration, expressions that do something on each iteration, and expressions that
do something right before the Loop exits. In addition, Loop expressions can
return a value. It is very rare to use all of these parts in a given Loop
expression, but you can combine them in many ways.
The source of this tutorial is Tutorial for the Common Lisp Loop Macro
and appears here by permission of Peter Karp.

Examples

Iterate through a list, and print each element.

* (loop for x in '(a b c d e)
      do (print x) )

A
B
C
D
E
NIL
Iterate through two lists in parallel, and cons up a result that is returned as
a value by Loop.
* (loop for x in '(a b c d e)
      for y in '(1 2 3 4 5)
      collect (list x y) )

((A 1) (B 2) (C 3) (D 4) (E 5))
Iterate using a counter, and a variable whose value is computed from an
expression on each iteration.
* (loop for x from 1 to 5
      for y = (* x 2)
      collect y)

(2 4 6 8 10)
Iterate through a list, and have a counter iterate in parallel. The length of
the list determines when the iteration ends. Two sets of actions are defined,
one of which is executed conditionally.
* (loop for x in '(a b c d e)
      for y from 1

      when (> y 1)
      do (format t ", ")

      do (format t "~A" x)
      )

A, B, C, D, E
NIL

We could also write the preceding loop using the IF construct.

* (loop for x in '(a b c d e)
      for y from 1

      if (> y 1)
      do (format t ", ~A" x)
      else do (format t "~A" x)
      )

A, B, C, D, E
NIL
Terminate the loop early using a test. Actions can consist of arbitrarily many
lines and can refer to variables defined outside the lexical scope of the loop.
* (loop for x in '(a b c d e 1 2 3 4)
    until (numberp x)
    collect (list x 'foo))

((A FOO) (B FOO) (C FOO) (D FOO) (E FOO))

“While” can also serve as a termination check. Both “do” and “collect” can be combined in one expression.

* (loop for x from 1
      for y = (* x 10)
      while (< y 100)

      do (print (* x 5))

      collect y)

5
10
15
20
25
30
35
40
45
(10 20 30 40 50 60 70 80 90)

Loops can be nested in various ways

* (loop for x from 1 to 10
      collect (loop for y from 1 to x
            collect y) )

((1) (1 2) (1 2 3) (1 2 3 4) (1 2 3 4 5) (1 2 3 4 5 6) (1 2 3 4 5 6 7)
 (1 2 3 4 5 6 7 8) (1 2 3 4 5 6 7 8 9) (1 2 3 4 5 6 7 8 9 10))

Several variables can loop through the components of a complex list.

* (loop for (a b) in '((x 1) (y 2) (z 3))
      collect (list b a) )

((1 X) (2 Y) (3 Z))
The “return” action both stops the loop and returns a result. Here we return the
first numeric character in the string s.
* (let ((s "alpha45"))
  (loop for i from 0 below (length s)
    for ch =  (char s i)
    when (find ch "0123456789" :test #'eql)
    return ch) )

#\4

Several actions provide shorthands for combinations of when/return

* (loop for x in '(foo 2)
      thereis (numberp x))
T

* (loop for x in '(foo 2)
      never (numberp x))
NIL

* (loop for x in '(foo 2)
      always (numberp x))
NIL