We can turn to the environment model to see how 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 function

function make_withdraw(balance) {
    return amount => {
               if (balance >= amount) {
                   balance = balance - amount;
                   return balance;
               } else {
                   return "insufficient funds";
               }
           };
}

Let us describe the evaluation of

const W1 = make_withdraw(100);

followed by

W1(50);

50

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

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

const W1 = make_withdraw(100);

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

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

W1(50);

50

We begin by constructing a frame in which amount, the 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 program environment, but rather the environment E1, because this is the environment that is specified by the W1 function object. Within this new environment, we evaluate the body of the function:

if (balance >= amount) {
    balance = balance - amount;
    return balance;
} else {
    return "insufficient funds";
}

The resulting environment structure is shown in figure 3.16. The expression being evaluated references both amount and balance. 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.

When the 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 function object W1. The frame that binds amount (in which we executed the code that changed balance) is no longer relevant, since the 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 function object W1. Figure 3.18 shows the situation after the call to W1.

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

const W2 = make_withdraw(100);

This produces the environment structure of figure 3.20, which shows that W2 is a 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. 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 expression in the body of make_withdraw.

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.