Section 1.1.8 introduced the idea that procedures functions can have internal definitions, function definitions, thus leading to a block structure as in the following procedure function to compute square roots:

Original	Python
(define (sqrt x) (define (good-enough? guess) (< (abs (- (square guess) x)) 0.001)) (define (improve guess) (average guess (/ x guess))) (define (sqrt-iter guess) (if (good-enough? guess) guess (sqrt-iter (improve guess)))) (sqrt-iter 1.0))	def sqrt(x): def is_good_enough(guess): return abs(square(guess) - x) < 0.001 def improve(guess): return average(guess, x / guess) def sqrt_iter(guess): return (guess if is_good_enough(guess) else sqrt_iter(improve(guess))) return sqrt_iter(1)

Now we can use the environment model to see why these internal definitions behave as desired. Figure 3.13 Figure 3.14 shows the point in the evaluation of the expression (sqrt 2) sqrt(2) where the internal procedure function good-enough? is_good_enough has been called for the first time with guess equal to 1.

Original		Python
Figure 3.13 sqrt procedure with internal definitions.		Figure 3.14 The sqrt function with internal definitions.

Observe the structure of the environment. Sqrt is a symbol in the global environment that is bound The name sqrt is bound in the global environment to a procedure function object whose associated environment is the global environment. When sqrt was called, a new environment, E1, was formed, subordinate to the global environment, in which the parameter x is bound to 2 and in which the locally defined function names is_good_enough, improve, and sqrt_iter are initially unassigned. The body of sqrt was then evaluated in E1.

Original		Python
Since the first expression in the body of sqrt is		Since the first statement in the body is

Original	Python
(define (good-enough? guess) (< (abs (- (square guess) x)) 0.001))	def is_good_enough(guess): return abs(square(guess) - x) < 0.001

Original		Python
evaluating this expression defined the procedure good-enough? in the environment E1.		evaluating this definition created the function is_good_enough in the environment E1.

Original		Python
To be more precise, the symbol good-enough? was added to the first frame of E1, bound to a procedure object whose associated environment is E1.		To be more precise, the name is_good_enough in the first frame of E1 was bound to a function object whose associated environment is E1.

Similarly, improve and sqrt-iter sqrt_iter were defined as procedures in E1. functions in E1. For conciseness, figure 3.13 figure 3.14 shows only the procedure function object for good-enough?. is_good_enough.

After the local procedures functions were defined, the expression (sqrt-iter 1.0) sqrt_iter(1) was evaluated, still in environment E1. E1. So the procedure function object bound to sqrt-iter in E1 was called with 1 as an argument. This created an environment E2 in which sqrt_iter in E1 was called with 1 as an argument. This created an environment E2 in which guess, the parameter of sqrt-iter, sqrt_iter, is bound to 1. sqrt-iter The function sqrt_iter in turn called good-enough? is_good_enough with the value of guess (from E2) as the argument for good-enough?. (from E2) as the argument for is_good_enough. This set up another environment, E3, in which guess (the parameter of good-enough?) E3, in which guess (the parameter of is_good_enough) is bound to 1. Although sqrt-iter sqrt_iter and good-enough? is_good_enough both have a parameter named guess, these are two distinct local variables located in different frames.

Original		Python
Also, E2 and E3 both have E1 as their enclosing environment, because the sqrt-iter and good-enough? procedures both have E1 as their environment part.		Also, E2 and E3 both have E1 as their enclosing environment, because the sqrt_iter and is_good_enough functions both have E1 as their environment part.

One consequence of this is that the symbol name x that appears in the body of good-enough? is_good_enough will reference the binding of x that appears in E1, namely the value of x with which the original sqrt procedure function was called.

The environment model thus explains the two key properties that make local procedure definitions function definitions a useful technique for modularizing programs:

• The names of the local procedures functions do not interfere with names external to the enclosing procedure, function, because the local procedure function names will be bound in the frame that the procedure function creates when it is run, rather than being bound in the global environment.
• The local procedures functions can access the arguments of the enclosing procedure, simply by using parameter names as free variables. parameters and local names of the enclosing function, simply by using these names as free names. This is because the body of the local procedure function is evaluated in an environment that is subordinate to the evaluation environment for the enclosing procedure. function.