Special form of letrec
Because internal definitions look sequential but are actually simultaneous, some people prefer to avoid them entirely, and use the special form
letrec
instead.
Letrec
looks like
let
, so it is not surprising that the variables it binds are bound simultaneously and have the same scope as each other. The sample procedure
f
above can be written without internal definitions, but with exactly the same meaning, as
(define (f x)
(letrec ((even?
(lambda (n)
(if (= n 0)
true
(odd? (- n 1)))))
(odd?
(lambda (n)
(if (= n 0)
false
(even? (- n 1))))))
<rest of body of f>))
letrec
expressions, which have the form
(letrec ((<var1> <exp1>) ... (<varn> <expn>))
body)are a variation on
let
in which the expressions
<expk>
that provide the initial values for the variables
<vark>
are evaluated in an environment that includes all the
letrec
bindings. This permits recursion in the bindings, such as the mutual recursion of
even?
and
odd?
in the example above, or the evaluation of
10
factorial with
(letrec ((fact
(lambda (n)
(if (= n 1)
1
(* n (fact (- n 1)))))))
(fact 10))a. Implement
letrec
as a derived expression, by transforming a
letrec
expression into a
let
expression as shown in the text above or in exercise
4.18
. That is, the
letrec
variables should be created with a
let
and then be assigned their values with
set!
.
b. Louis Reasoner is confused by all this fuss about internal definitions. The way he sees it, if you don't like to use
define
inside a procedure, you can just use
let
. Illustrate what is loose about his reasoning by drawing an environment diagram that shows the environment in which the
<rest of body of f>
is evaluated during evaluation of the expression
(f 5)
, with
f
defined as in this exercise. Draw an environment diagram for the same evaluation, but with
let
in place of
letrec
in the definition of
f
.