Scheme has only few iteration mechanisms, mainly because iteration in
Scheme programs is normally expressed using recursion. Nevertheless,
R5RS defines a construct for programming loops, calling
addition, Guile has an explicit looping syntax called
Bind variables and evaluate body until test is true. The return value is the last expr after test, if given. A simple example will illustrate the basic form,(do ((i 1 (1+ i))) ((> i 4)) (display i)) -| 1234
Or with two variables and a final return value,(do ((i 1 (1+ i)) (p 3 (* 3 p))) ((> i 4) p) (format #t "3**~s is ~s\n" i p)) -| 3**1 is 3 3**2 is 9 3**3 is 27 3**4 is 81 ⇒ 789
The variable bindings are established like a
let, in that the expressions are all evaluated and then all bindings made. When iterating, the optional step expressions are evaluated with the previous bindings in scope, then new bindings all made.
The test expression is a termination condition. Looping stops when the test is true. It's evaluated before running the body each time, so if it's true the first time then body is not run at all.
The optional exprs after the test are evaluated at the end of looping, with the final variable bindings available. The last expr gives the return value, or if there are no exprs the return value is unspecified.
Each iteration establishes bindings to fresh locations for the variables, like a new
letfor each iteration. This is done for variables without step expressions too. The following illustrates this, showing how a new
iis captured by the
lambdain each iteration (see The Concept of Closure).(define lst '()) (do ((i 1 (1+ i))) ((> i 4)) (set! lst (cons (lambda () i) lst))) (map (lambda (proc) (proc)) lst) ⇒ (4 3 2 1)
Run a loop executing the body forms while cond is true. cond is tested at the start of each iteration, so if it's
#fthe first time then body is not executed at all. The return value is unspecified.
while, two extra bindings are provided, they can be used from both cond and body.— Scheme Procedure: continue
Abandon the current iteration, go back to the start and test cond again, etc.
whileform gets its own
continueprocedures, operating on that
while. This means when loops are nested the outer
breakcan be used to escape all the way out. For example,(while (test1) (let ((outer-break break)) (while (test2) (if (something) (outer-break #f)) ...)))
Note that each
continueprocedure can only be used within the dynamic extent of its
while. Outside the
whiletheir behaviour is unspecified.
Another very common way of expressing iteration in Scheme programs is the use of the so-called named let.
Named let is a variant of
let which creates a procedure and calls
it in one step. Because of the newly created procedure, named let is
more powerful than
do–it can be used for iteration, but also
for arbitrary recursion.
For the definition of bindings see the documentation about
let(see Local Bindings).
letworks as follows:
- A new procedure which accepts as many arguments as are in bindings is created and bound locally (using
let) to variable. The new procedure's formal argument names are the name of the variables.
- The body expressions are inserted into the newly created procedure.
- The procedure is called with the init expressions as the formal arguments.
The next example implements a loop which iterates (by recursion) 1000 times.(let lp ((x 1000)) (if (positive? x) (lp (- x 1)) x)) ⇒ 0