Node:Local Bindings, Next:Internal Definitions, Previous:Top Level, Up:Binding Constructs
As opposed to definitions at the top level, which are visible in the whole program (or current module, when Guile modules are used), it is also possible to define variables which are only visible in a well-defined part of the program. Normally, this part of a program will be a procedure or a subexpression of a procedure.
With the constructs for local binding (
letrec), the Scheme language has a block structure like most
other programming languages since the days of ALGOL 60. Readers
familiar to languages like C or Java should already be used to this
concept, but the family of
let expressions has a few properties
which are well worth knowing.
The first local binding construct is
let. The other constructs
letrec are specialized versions for usage where
let is a bit inconvenient.
|let bindings body||syntax|
bindings has the form
((variable1 init1) ...)
that is zero or more two-element lists of a variable and an arbitrary expression each. All variable names must be distinct.
The init expressions are not allowed to refer to any of the variables.
|let* bindings body||syntax|
Similar to |
(let* ((a 1) (b a)) b) == (let ((a 1)) (let ((b a)) b))
|letrec bindings body||syntax|
Similar to |
(letrec ((even? (lambda (n) (if (zero? n) #t (odd? (- n 1))))) (odd? (lambda (n) (if (zero? n) #f (even? (- n 1)))))) (even? 88)) => #t
There is also an alternative form of the
let form, which is used
for expressing iteration. Because of the use as a looping construct,
this form (the named let) is documented in the section about
iteration (see Iteration)