This recursive procedure calculates the factorial of a number. If the number is 0, the
answer is 1. For any other number n, the
procedure uses itself to calculate the factorial of
n-1, multiplies that subresult by n, and
returns the product.
Mutually recursive procedures are also possible. The
following predicates for evenness and oddness use each
other:
This won't quite work, because the occurrences of
local-even? and local-odd? in the initializations
don't refer to the lexical variables themselves.
Changing the let to a let* won't work either,
for while the local-even? inside local-odd?'s body
refers to the correct procedure value, the local-odd?
in local-even?'s body still points elsewhere.
To solve problems like this, Scheme provides the form
letrec:
The lexical variables introduced by a letrec are
visible not only in the letrec-body but also within
all the initializations. letrec is thus
tailor-made for defining recursive and mutually
recursive local procedures.
Note the presence of a variable identifying the loop
immediately after the let. This program is
equivalent to the one written with letrec. You may
consider the named let to be a macro
(chap 8) expanding to the letrec form.
countdown defined above is really a recursive
procedure. Scheme can define loops only through
recursion. There are no special looping or iteration
constructs.
Nevertheless, the loop as defined above is a genuine loop, in exactly the same way that other
languages bill their loops. Ie, Scheme takes special
care to ensure that recursion of the type used above
will not generate the procedure call/return overhead.
Scheme does this by a process called tail-call
elimination. If you look closely at the countdown
procedure, you will note that when the recursive call
occurs in countdown's body, it is the tail call,
or the very last thing done -- each invocation of
countdown either does not call itself, or when it
does, it does so as its very last act. To a Scheme
implementation, this makes the recursion
indistinguishable from iteration. So go ahead, use
recursion to write loops. It's safe.
Here's another example of a useful tail-recursive
procedure:
list-position finds the index of the first
occurrence of the object o in the list l. If
the object is not found in the list, the procedure
returns #f.
Here's yet another tail-recursive procedure, one that
reverses its argument list ``in place'', ie, by mutating
the contents of the existing list, and without
allocating a new one:
(definereverse!
(lambda (s)
(letloop ((ss) (r'()))
(if (null?s) r
(let ((d (cdrs)))
(set-cdr!sr)
(loopds))))))
(reverse! is a useful enough procedure that it is
provided primitively in many Scheme dialects, eg,
MzScheme and Guile.)
For some numerical examples of recursion (including iteration),
see Appendix C.
A special kind of iteration involves repeating the same
action for each element of a list. Scheme offers two
procedures for this situation: map and for-each.
The map procedure applies a given procedure to every
element of a given list, and returns the list of the
results. Eg,
(mapadd2'(123))
=> (345)
The for-each procedure also applies a procedure to each
element in a list, but returns void. The procedure
application is done purely for any side-effects it may
cause. Eg,
(for-eachdisplay
(list"one ""two ""buckle my shoe"))
has the side-effect of displaying the strings (in
the order they appear) on the console.
The procedures applied by map and for-each
need not be one-argument procedures. For example,
given an n-argument procedure, map
takes n lists and applies the procedure to
every set of n of arguments selected from across
the lists. Eg,