We can turn to the environment model to see how procedures functions and assignment can be used to represent objects with local state. As an example, consider the withdrawal processor from section 3.1.1 created by calling the procedure function

Original	JavaScript
(define (make-withdraw balance) (lambda (amount) (if (>= balance amount) (begin (set! balance (- balance amount)) balance) "Insufficient funds")))	function make_withdraw(balance) { return amount => { if (balance >= amount) { balance = balance - amount; return balance; } else { return "insufficient funds"; } }; }

Let us describe the evaluation of

Original	JavaScript
(define W1 (make-withdraw 100))	const W1 = make_withdraw(100);

followed by

Original	JavaScript
(W1 50) 50	W1(50); 50

Figure 3.11 Figure 3.12 shows the result of defining the make-withdraw declaring the make_withdraw procedure function in the global program environment. This produces a procedure function object that contains a pointer to the global program environment. So far, this is no different from the examples we have already seen, except that the body of the procedure is itself a lambda expression. the return expression in the body of the function is itself a lambda expression.

Original		JavaScript
Figure 3.11 Result of defining make-withdraw in the global environment.		Figure 3.12 Result of defining make_withdraw in the program environment.

The interesting part of the computation happens when we apply the procedure function make-withdraw make_withdraw to an argument:

Original	JavaScript
(define W1 (make-withdraw 100))	const W1 = make_withdraw(100);

We begin, as usual, by setting up an environment E1 in which the formal parameter balance is bound to the argument 100. Within this environment, we evaluate the body of make-withdraw, make_withdraw, namely the lambda expression. This return statement whose return expression is a lambda expression. The evaluation of this lambda expression constructs a new procedure function object, whose code is as specified by the lambda lambda expression and whose environment is E1, the environment in which the lambda lambda expression was evaluated to produce the procedure. function. The resulting procedure function object is the value returned by the call to make-withdraw. make_withdraw. This is bound to W1 in the global program environment, since the define constant declaration itself is being evaluated in the global program environment. Figure 3.13 Figure 3.14 shows the resulting environment structure.

Original		JavaScript
Figure 3.13 Result of evaluating (define W1 (make-withdraw 100)).		Figure 3.14 Result of evaluating const W1 = make_withdraw(100);.

Now we can analyze what happens when W1 is applied to an argument:

Original	JavaScript
(W1 50) 50	W1(50); 50

We begin by constructing a frame in which amount, the formal parameter of W1, is bound to the argument 50. The crucial point to observe is that this frame has as its enclosing environment not the global program environment, but rather the environment E1, because this is the environment that is specified by the W1 procedure function object. Within this new environment, we evaluate the body of the procedure: function:

Original	JavaScript
(if (>= balance amount) (begin (set! balance (- balance amount)) balance) "Insufficient funds")	if (balance >= amount) { balance = balance - amount; return balance; } else { return "insufficient funds"; }

The resulting environment structure is shown in figure 3.15. figure 3.16. The expression being evaluated references both amount and balance. Amount The variable amount will be found in the first frame in the environment, and balance will be found by following the enclosing-environment pointer to E1.

Original		JavaScript
Figure 3.15 Environments created by applying the procedure object W1.		Figure 3.16 Environments created by applying the function object W1.

When the set! assignment is executed, the binding of balance in E1 is changed. At the completion of the call to W1, balance is 50, and the frame that contains balance is still pointed to by the procedure function object W1. The frame that binds amount (in which we executed the code that changed balance) is no longer relevant, since the procedure function call that constructed it has terminated, and there are no pointers to that frame from other parts of the environment. The next time W1 is called, this will build a new frame that binds amount and whose enclosing environment is E1. We see that E1 serves as the place that holds the local state variable for the procedure function object W1. Figure 3.17 Figure 3.18 shows the situation after the call to W1.

Original		JavaScript
Figure 3.17 Environments after the call to W1.		Figure 3.18 Environments after the call to W1.

Observe what happens when we create a second withdraw object by making another call to make_withdraw: make_withdraw:

Original	JavaScript
(define W2 (make-withdraw 100))	const W2 = make_withdraw(100);

This produces the environment structure of figure 3.19, figure 3.20, which shows that W2 is a procedure function object, that is, a pair with some code and an environment. The environment E2 for W2 was created by the call to make-withdraw. make_withdraw. It contains a frame with its own local binding for balance. On the other hand, W1 and W2 have the same code: the code specified by the lambda lambda expression in the body of make-withdrawmake_withdraw.[1] We see here why W1 and W2 behave as independent objects. Calls to W1 reference the state variable balance stored in E1, whereas calls to W2 reference the balance stored in E2. Thus, changes to the local state of one object do not affect the other object.

Original		JavaScript
Figure 3.19 Using (define W2 (make-withdraw 100)) to create a second object.		Figure 3.20 Using const W2 = make_withdraw(100); to create a second object.

Exercise 3.10 In the make-withdraw make_withdraw procedure, function the local variable balance is created as a parameter of make-withdraw. make_withdraw. We could also create the local state variable explicitly, separately, using let, what we might call an immediately invoked lambda expression as follows:

Original	JavaScript
(define (make-withdraw initial-amount) (let ((balance initial-amount)) (lambda (amount) (if (>= balance amount) (begin (set! balance (- balance amount)) balance) "Insufficient funds"))))	function make_withdraw(initial_amount) { return (balance => amount => { if (balance >= amount) { balance = balance - amount; return balance; } else { return "insufficient funds"; } })(initial_amount); }

Original		JavaScript
Recall from section 1.3.2 that let is simply syntactic sugar for a procedure function call: (let ((var exp)) body) is interpreted as an alternate syntax for ((lambda (var) body) exp)		The outer lambda expression is invoked immediately after it is evaluated. Its only purpose is to create a local variable balance and initialize it to initial_amount.

Use the environment model to analyze this alternate version of make_withdraw, drawing figures like the ones above to illustrate the interactions

Original	JavaScript
(define W1 (make-withdraw 100)) (W1 50) (define W2 (make-withdraw 100))	const W1 = make_withdraw(100); W1(50); const W2 = make_withdraw(100);

Show that the two versions of make-withdraw make_withdraw create objects with the same behavior. How do the environment structures differ for the two versions?

Solution

• Black shows the environment structure of function in exercise 3.10
• Green shows differences in environment structure of original (where make_withdraw is replaced with the figure 3.9 version)