Node:while do, Next:, Previous:and or, Up:Control Mechanisms


26.4 Iteration mechanisms

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 do. In addition, Guile has an explicit looping syntax called while.

do ((variable1 init1 step1) ...) (test expr ...) command ... syntax
The init expressions are evaluated and the variables are bound to their values. Then looping starts with testing the test expression. If test evaluates to a true value, the expr following the test are evaluated and the value of the last expr is returned as the value of the do expression. If test evaluates to false, the commands are evaluated in order, the steps are evaluated and stored into the variables and the next iteration starts.

Any of the step expressions may be omitted, so that the corresponding variable is not changed during looping.

while cond body ... syntax
Evaluate all expressions in body in order, as long as cond evaluates to a true value. The cond expression is tested before every iteration, so that the body is not evaluated at all if cond is #f right from the start.

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.

let variable bindings body syntax
For the definition of bindings see the documentation about let (see Local Bindings).

Named let works 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