Internal definitions
Definitions can occur at the
beginning of a body (that is, the body of a lambda,
let, let*, letrec, letrec*,
let-values, let*-values, let-syntax, letrec-syntax,
parameterize, guard, or case-lambda). Note that
such a body might not be apparent until after expansion of other syntax.
Such definitions are known as internal definitions
as opposed to the global definitions described above.
The variables defined by internal definitions are local to the
body. That is, variable is bound rather than assigned,
and the region of the binding is the entire body. For example,
(let ((x 5))
(define foo (lambda (y) (bar x y)))
(define bar (lambda (a b) (+ (* a b) a)))
(foo (+ x 3))) ==> 45
An expanded body containing internal definitions
can always be
converted into a completely equivalent letrec* expression. For
example, the let expression in the above example is equivalent
to
(let ((x 5))
(letrec* ((foo (lambda (y) (bar x y)))
(bar (lambda (a b) (+ (* a b) a))))
(foo (+ x 3))))
Just as for the equivalent letrec* expression, it is an error if it is not
possible to evaluate each expression of every internal
definition in a body without assigning or referring to
the value of the corresponding variable or the variable
of any of the definitions that follow it in body.
It is an error to define the same identifier more than once in the
same body.
Wherever an internal definition can occur,
(begin {definition1} ...)
is equivalent to the sequence of definitions
that form the body of the begin.
|
