Syntax:
Formals is a formal arguments list as described below,
and body is a sequence of zero or more definitions
followed by one or more expressions.
Semantics:
A lambda expression evaluates to a procedure. The environment in
effect when the lambda expression was evaluated is remembered as part of the
procedure. When the procedure is later called with some actual
arguments, the environment in which the lambda expression was evaluated will
be extended by binding the variables in the formal argument list to
fresh locations, and the corresponding actual argument values will be stored
in those locations.
(A fresh location is one that is distinct from every previously
existing location.)
Next, the expressions in the
body of the lambda expression (which, if it contains definitions,
represents a letrec* form -- see section 4.2.2)
will be evaluated sequentially in the extended environment.
The results of the last expression in the body will be returned as
the results of the procedure call.
(lambda (x) (+ x x)) ==> a procedure
((lambda (x) (+ x x)) 4) ==> 8
(define reverse-subtract
(lambda (x y) (- y x)))
(reverse-subtract 7 10) i ==> 3
(define add4
(let ((x 4))
(lambda (y) (+ x y))))
(add4 6) ==> 10
Formals have one of the following forms:
-
({variable1} ...):
The procedure takes a fixed number of arguments; when the procedure is
called, the arguments will be stored in fresh locations
that are bound to the corresponding variables.
-
{variable}:
The procedure takes any number of arguments; when the procedure is
called, the sequence of actual arguments is converted into a newly
allocated list, and the list is stored in a fresh location
that is bound to
variable.
-
({variable1} ... {variablen} . {variablen+1}):
If a space-delimited period precedes the last variable, then
the procedure takes n
or more arguments, where
n is the
number of formal arguments before the period (it is an error if there is not
at least one).
The value stored in the binding of the last variable will be a
newly allocated
list of the actual arguments left over after all the other actual
arguments have been matched up against the other formal arguments.
It is an error for a variable to appear more than once in
formals.
((lambda x x) 3 4 5 6) ==> (3 4 5 6)
((lambda (x y . z) z)
3 4 5 6) ==> (5 6)
Each procedure created as the result of evaluating a lambda expression is
(conceptually) tagged
with a storage location, in order to make eqv? and
eq? work on procedures (see section 6.1).
