Consider for example the following function:
(lambda (a b c) (+ a b c))
We can call this function by writing it as the car of an expression, like this:
((lambda (a b c) (+ a b c)) 1 2 3)
This call evaluates the body of the lambda expression with the variable
a bound to 1,
b bound to 2, and
c bound to 3.
Evaluation of the body adds these three numbers, producing the result 6;
therefore, this call to the function returns the value 6.
Note that the arguments can be the results of other function calls, as in this example:
((lambda (a b c) (+ a b c)) 1 (* 2 3) (- 5 4))
This evaluates the arguments
(* 2 3), and
4) from left to right. Then it applies the lambda expression to the
argument values 1, 6 and 1 to produce the value 8.
It is not often useful to write a lambda expression as the car of
a form in this way. You can get the same result, of making local
variables and giving them values, using the special form
(see Local Variables). And
let is clearer and easier to use.
In practice, lambda expressions are either stored as the function
definitions of symbols, to produce named functions, or passed as
arguments to other functions (see Anonymous Functions).
However, calls to explicit lambda expressions were very useful in the
old days of Lisp, before the special form
let was invented. At
that time, they were the only way to bind and initialize local