1. Lecture 13 - Assignment and the environments model Chapter 3
מבוא מורחב - שיעור 13

2. Primitive Data constructor:
(define x 10) creates a new binding for name;
special form
selector: x returns value bound to name
mutator: (set! x "foo") changes the binding for name; special form
מבוא מורחב

3. Assignment -- set!
Substitution model -- functional programming: (define x 10) (+ x 5) ==> 15 - expression has same value each time it evaluated (in (+ x 5) ==> same scope as binding)
With assignment: (define x 10) (+ x 5) ==> expression "value" depends on when it is evaluated (set! x 94) ... (+ x 5) ==> 99
מבוא מורחב

4. Why? To have objects with local state
The state is summarized in a set of variables.
When the object changes its state the variable changes its value.
מבוא מורחב

5. Procedures with local state
Suppose we want to implement counters
(define ca (make-counter 0))
(ca) ==> 1
(ca) ==> 2
(define cb (make-counter 0))
(cb) ==> 1
(ca) ==> 3
How can we define such procedures?
מבוא מורחב - שיעור 13

6. A counter: an object with state
(define make-counter (lambda (n) (lambda ()(set! n (+ n 1)) n )))
set! does assignment to an already defined variable.
It is a special form.
(define ca (make-counter 0))
ca is a procedure.
Variable n is its local state.
מבוא מורחב - שיעור 13

7. Can the substitution model explain this behavior?
(define make-counter (lambda (n) (lambda () (set! n (+ n 1)) n )))
(define ca (make-counter 0))
ca ==> (lambda () (set! 0 (+ 0 1)) 0)
(ca)
((set! 0 (+ 0 1)) 0)
==> ?
The substitution model is not adequate for assignment!
מבוא מורחב - שיעור 13

8. The Environments Model
Name Value
Environment Table 23
score
Substitution model: a single global environment
Environments model: many environments.
Generalizes the substitution model.
As we noted earlier in the course, we need to change models to explain a more complex universe, in the same way that in Physics one needs to abandon the Newtonian model in order to reason effectively about sub-atomic particles.
מבוא מורחב - שיעור 13

9. Frame: a table of bindings
Binding: a pairing of a name and a value
Example: x is bound to 15 in frame A y is bound to (1 2) in frame A the value of the variable x in frame A is 15 2 1
x: 15 A y:
מבוא מורחב - שיעור 13

10. Environment: a sequence of frames
Environment E1 consists of frames A and B
Environment E2 consists of frame B only
A frame may be shared by multiple environments
z: 10 B E1
this arrow is called the enclosing environment pointer E2
x: 15 A 2 1 y:
מבוא מורחב - שיעור 13

11. Evaluation in the environment model
All evaluations occur in an environment
The current environment changes when the interpreter applies a procedure
The top environment is called the global environment (GE)
Only the GE has no enclosing environment
מבוא מורחב - שיעור 13

12. The Environment Model
A precise, completely mechanical, description of:
name-rule looking up the value of a variable
define-rule creating a new definition of a var
set!-rule changing the value of a variable
lambda-rule creating a procedure
application rule applying a procedure
Enables analyzing arbitrary scheme code:
Example: make-counter
As we noted earlier in the course, we need to change models to explain a more complex universe, in the same way that in Physics one needs to abandon the Newtonian model in order to reason effectively about sub-atomic particles.
Basis for implementing a scheme interpreter
for now: draw EM state with boxes and pointers
later on: implement with code
מבוא מורחב - שיעור 13

13. Name-rule
A name X evaluated in environment E gives the value of X in the first frame of E where X is bound
z | GE ==> z | E1 ==> x | E1 ==> 15
In E1, the binding of x in frame A shadows the binding of x in B
x | GE ==> 3
x: 15 A 2 1
z: 10 x: 3 B E1 GE y:
מבוא מורחב - שיעור 13

14. Define-rule
A define special form evaluated in environment E creates or replaces a binding in the first frame of E
(define z 20) | GE
(define z 25) | E1
x: 15 A 2 1
z: 10 x: 3 B E1 GE y:
z: 20
z: 25
מבוא מורחב - שיעור 13

15. Set!-rule
A set! of variable X evaluated in environment E changes the binding of X in the first frame of E where X is bound
(set! z 20) | GE
(set! z 25) | E1
x: 15 A 2 1
z: 10 x: 3 B E1 GE y: 20 25
מבוא מורחב - שיעור 13

16. Your turn: evaluate the following in order
(+ z 1) | E ==>
(set! z (+ z 1)) | E (modify EM)
(define z (+ z 1)) | E (modify EM)
(set! y (+ z 1)) | GE (modify EM) 11
Error: unbound variable: y B
z: 10 x: 3 11 GE A
x: 15
z: 12 E1 y: 2 1
מבוא מורחב - שיעור 13

17. Double bubble: how to draw a procedure
(lambda (x) (* x x))
eval lambda-rule
A compound proc that squares its argument
#[proc-...]
print
Environment pointer
Code pointer
parameters: x body: (* x x)
מבוא מורחב - שיעור 13

18. Lambda-rule
A lambda special form evaluated in environment E creates a procedure whose environment pointer points to E
(define square (lambda (x) (* x x))) | E1
x: 15 A
z: 10 x: 3 B E1
environment pointer points to frame A because the lambda was evaluated in E1 and E1  A
square:
Evaluating a lambda actually returns a pointer to the procedure object
parameters: x body: (* x x)
מבוא מורחב - שיעור 13

19. To apply a compound procedure P to arguments (Application Rule)
1. Create a new frame A
2. Make A into an environment E: A's enclosing environment pointer goes to the same frame as the environment pointer of P
3. In A, bind the parameters of P to the argument values
4. Evaluate the body of P with E as the current environment
We recommend you memorize these four steps
מבוא מורחב - שיעור 13

20. (square 4) | GE square | GE ==> ==> 16 * | E1 ==> x | E1
*: #[prim] GE
square: E1
parameters: x body: (* x x) A
x: 4
square | GE
==>
frame becomes inaccessible
(* x x) | E1
==> 16
* | E1
==>
x | E1
==> 4
מבוא מורחב - שיעור 13

21. Example: inc-square inc-square: GE square: p: x b: (* x x)
p: y b: (+ 1 (square y)) GE
p: x b: (* x x)
square:
(define square (lambda (x) (* x x))) | GE
(define inc-square (lambda (y) (+ 1 (square y))) | GE
מבוא מורחב - שיעור 13

22. Example cont'd: (inc-square 4) | GE
p: x b: (* x x)
square:
inc-square:
p: y b: ( (square y)) E1
y: 4
inc-square | GE ==>
(+ 1 (square y)) | E1
+ | E1
==> #[prim]
(square y) | E1
מבוא מורחב - שיעור 13

23. Example cont'd: (inc-square 4) | E1GE
square: E1 E2
y: 4
x: 4
frames become inaccessible
p: x b: (* x x)
p: y b: ( (square y)) | E1
square | E1
==>
y | E1
==> 4
(* x x) | E2
==> 16
(+ 1 16) ==> 17
* | E2 ==> #[prim] x | E2 ==> 4
מבוא מורחב - שיעור 13

24. Example: explaining make-counter
Counter: an object that counts up starting from some integer
(define make-counter (lambda (n) (lambda () (set! n (+ n 1)) n ; returned and retained value
)))
(define ca (make-counter 0)) (ca) ==> 1 (ca) ==> 2 (define cb (make-counter 0)) (cb) ==> 1 (ca) ==> 3 (cb) ==> 2
מבוא מורחב - שיעור 13

25. (define ca (make-counter 0)) | GE
p: n b:(lambda () (set! n (+ n 1)) n)
make-counter:
ca: E1
E1 is pointed at so does not disappear!
n: 0
environment pointer points to E1 because the lambda was evaluated in E1
p: b:(set! n (+ n 1)) n
(lambda () (set! n (+ n 1)) n) | E1
מבוא מורחב - שיעור 13

26. (ca) | GE ==> 1 make-counter: GE ca: E1 n: 0 1
p: n b:(lambda () (set! n (+ n 1)) n)
p: b:(set! n (+ n 1)) n E2
Empty
(no args)
(set! n (+ n 1)) | E2
n | E2 ==> 1
מבוא מורחב - שיעור 13

27. (ca) | GE ==> 2 make-counter: GE ca: E1 n: 0 1
p: n b:(lambda () (set! n (+ n 1)) n) 2
p: b:(set! n (+ n 1)) n E3
empty
(set! n (+ n 1)) | E3
n | E3 ==> 2
מבוא מורחב - שיעור 13

28. Example: explaining make-counter
Counter: something which counts up from a number
(define make-counter (lambda (n) (lambda () (set! n (+ n 1)) n )))
(define ca (make-counter 0)) (ca) ==> 1 (ca) ==> 2 (define cb (make-counter 0)) (cb) ==> 1 (ca) ==> 3 (cb) ==> 2

29. (define ca (make-counter 0)) | GE
p: n b:(lambda () (set! n (+ n 1)) n)
make-counter:
ca: E1
n: 0
environment pointer points to E1 because the lambda was evaluated in E1
p: b:(set! n (+ n 1)) n
(lambda () (set! n (+ n 1)) n) | E1

30. (ca) | GE ==> 1 GE p: n b:(lambda () (set! n (+ n 1)) n)
make-counter: E1
n: 0
p: b:(set! n (+ n 1)) n
ca: 1 E2
empty
(set! n (+ n 1)) | E2
n | E2 ==> 1

31. (ca) | GE ==> 2 GE p: n b:(lambda () (set! n (+ n 1)) n)
make-counter: E1
n: 0
p: b:(set! n (+ n 1)) n
ca: 1 2 E3
empty
(set! n (+ n 1)) | E3
n | E3 ==> 2

32. (define cb (make-counter 0)) | GE
p: n b:(lambda () (set! n (+ n 1)) n)
make-counter: E1
n: 2
p: b:(set! n
(+ n 1)) n
ca: E3
cb: E4
n: 0
p: b:(set! n (+ n 1)) n
(lambda () (set! n (+ n 1)) n) | E4

33. (cb) | GE ==> 1 n: 0 E4 p: b:(set! n (+ n 1)) n cb: GE
p: n b:(lambda () (set! n (+ n 1)) n)
make-counter: E1
n: 2
p: b:(set! n
(+ n 1)) n
ca: E2 1 E5

34. Capturing state in local frames & procedures
p: b:(set! n (+ n 1)) n
cb: GE
p: n b:(lambda () (set! n (+ n 1)) n)
make-counter: E1
n: 2
p: b:(set! n
(+ n 1)) n
ca: E2

35. Lessons from the make-counter example
Environment diagrams get complicated very quickly
Rules are meant for the computer to follow, not to help humans
A lambda inside a procedure body captures the frame that was active when the lambda was evaluated
this effect can be used to store local state

36. Explaining Nested Definitions
Nested definitions : block structure
(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))
מבוא מורחב - שיעור 13

37. p: x b:(define good-enou ..) (define improve ..) sqrt:
(sqrt 2) | GE GE
p: x b:(define good-enou ..) (define improve ..)
(define sqrt-iter ..)
(sqrt-iter 1.0)
sqrt: E1
x: 2
good-enough:
p: guess b:(< (abs ….)
The same x in all
subprocedures
improve:
sqrt-iter:
guess: 1
sqrt-iter
guess: 1
good-enou?
מבוא מורחב - שיעור 13

38. message passing example
(define (cons x y)
(define (dispatch op)
(cond ((eq? op 'car) x)
((eq? op 'cdr) y)
(else
(error "Unknown op -- CONS" op))))
dispatch)
(define (car x) (x 'car))
(define (cdr x) (x 'cdr))
This code was modeled on the board. Recall that we explained that this example shows how
Scheme’s “static scoping” comes to play. By this we mean that even though the procedure dispatch
Pointed to by “a” is called from within the car procedure, our static scoping model that looks for
variables in the env the procedure was defined in, causes us to look for x in the env where dispatch was
Created, and thus we find the correct variable x to return, the one with value 1.
(define a (cons 1 2))
(car a)
מבוא מורחב - שיעור 13

39. (define a (cons 1 2)) | GE cons: car: cdr: GE a: E1 x: 1 y: 2
p: x y b:(define
(dispatch op)
..)
dispatch
cons:
car:
cdr: a: E1
x: 1
y: 2
p: x b:(x ‘car)
p: x b:(x ‘cdr)
dispatch:
p: op
b:(cond ((eq? op 'car) x)
.... )
מבוא מורחב - שיעור 13

40. (car a) | GE ==> 1 cons: car: cdr: GE a: E1 x: 1 y: 2 dispatch: E2
p: x y b:(define
(dispatch op)
..)
dispatch
cons:
car:
cdr: a: x: E2 E1
x: 1
y: 2
p: x b:(x ‘car)
p: x b:(x ‘cdr)
dispatch:
op: ‘car E3
p: op
b:(cond ((eq? op 'car) x)
.... )
(x ‘car) | E2
(cond ..) | E3 ==> 1
מבוא מורחב - שיעור 13