1 / 26

Understanding the Environment Model in Scheme: Code and Evaluation Mechanisms

This document delves into the Environment Model (EM) in Scheme, emphasizing its atomic principles like variable binding, procedure creation, and evaluation strategies. It explores the mechanics of state management in Scheme, illustrated with an example of a counter. You'll learn how independent counters operate, the significance of frames and bindings, and the differentiation between environments. The text discusses the lambda expressions, procedural evaluations, and the essential rules governing Scheme's operational semantics. An insightful read for Scheme enthusiasts and learners!

radwan
Télécharger la présentation

Understanding the Environment Model in Scheme: Code and Evaluation Mechanisms

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 6.001 SICPEnvironment model ; Can you figure out why this code works? (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 ; ca and cb are independent

  2. What the EM is: • 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 applying a procedure • Enables analyzing arbitrary scheme code: • Example: make-counter • Basis for implementing a scheme interpreter • for now: draw EM state with boxes and pointers • later on: implement with code

  3. A shift in viewpoint • As we introduce the environment model, we are going to shift our viewpoint on computation • Variable: • OLD – name for value • NEW – place into which one can store things • Procedure: • OLD – functional description • NEW – object with inherited context • Expressions • Now only have meaning with respect to an environment

  4. A x: 15 y: 1 2 Frame: a table of bindings • Binding: a pairing of a name and a value Example: x is bound to 15 in frame Ay is bound to (1 2) in frame A the value of the variable x in frame A is 15

  5. B z: 10 E2 A x: 15 E1 y: 1 2 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 this arrow is calledthe enclosingenvironment pointer

  6. Evaluation in the environment model • All evaluation occurs in an environment • The current environment changes when theinterpreter applies a procedure • The top environment is called the global environment (GE) • Only the GE has no enclosing environment • To evaluate a combination • Evaluate the subexpressions in the current environment • Apply the value of the first to the values of the rest

  7. In E1, the binding of x in frame A shadows the binding of x in B B • x | GE ==> 3 z: 10x: 3 GE A x: 15 E1 y: 1 2 Name-rule • A name X evaluated in environment E givesthe value of X in the first frame of E where X is bound • z | GE ==> 10 z | E1 ==> 10 x | E1 ==> 15

  8. B z: 10 x: 3 GE z: 20 A x: 15 y: E1 1 2 Define-rule • A define special form evaluated in environment Ecreates or replaces a binding in the first frame of E (define z 25) | E1 (define z 20) | GE z: 25

  9. B z: 10 x: 3 GE 20 25 A x: 15 y: E1 1 2 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

  10. 11 1 2 Your turn: evaluate the following in order 11 (+ z 1) | E1 ==> (set! z (+ z 1)) | E1 (modify EM) (define z (+ z 1)) | E1 (modify EM) (set! y (+ z 1)) | GE (modify EM) Error:unbound variable: y B z: 10x: 3 GE A x: 15 z: 12 E1 y:

  11. (lambda (x) (* x x)) print Environmentpointer #[compound-...] evallambda-rule A compound procthat squares itsargument Code pointer parameters: xbody: (* x x) Double bubble: how to draw a procedure

  12. B z: 10x: 3 A x: 15 E1 square: Evaluating a lambda actually returns a pointer to the procedure object parameters: xbody: (* x x) Lambda-rule • A lambda special form evaluated in environment Ecreates a procedure whose environment pointer is E (define square (lambda (x) (* x x)))| E1 environment pointerpoints to frame Abecause the lambdawas evaluated in E1and E1  A

  13. To apply a compound procedure P to arguments: 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 You mustmemorize thesefour steps

  14. A E1 (square 4) | GE (* x x) | E1 x: 10 *: #[prim] GE square: parameters: xbody: (* x x) x: 4 square | GE ==> #[proc] ==> 16 x | E1 ==> 4 * |E1 ==> #[prim]

  15. Example: inc-square (define square (lambda (x) (* x x))) | GE (define inc-square (lambda (y) (+ 1 (square y))) | GE inc-square: GE square: p: xb: (* x x) p: yb: (+ 1 (square y))

  16. inc-square: GE square: E1 p: xb: (* x x) p: yb: (+ 1 (square y)) Example cont'd: (inc-square 4) | GE y: 4 inc-square | GE ==> #[compound-proc ...] (+ 1 (square y)) | E1 + |E1 ==> #[prim] (square y) | E1

  17. inc-square: GE square: E2 E1 y: 4 p: xb: (* x x) p: yb: (+ 1 (square y)) Example cont'd: (square y) | E1 x: 4 square | E1 ==> #[compound] y | E1 ==> 4 (* x x) | E2 (+ 1 16) ==> 17 ==> 16 * |E2 ==> #[prim] x | E2 ==> 4

  18. Lessons from the inc-square example • EM doesn't show the complete state of the interpreter • missing the stack of pending operations • The GE contains all standard bindings (*, cons, etc) • omitted from EM drawings • Useful to link environment pointer of each frame to the procedure that created it

  19. Example: 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 ; ca and cb are independent

  20. make-counter: GE ca: E1 p: nb:(lambda () (set! n (+ n 1)) n) p: b:(set! n (+ n 1)) n (define ca (make-counter 0)) | GE n: 0 environment pointerpoints to E1because the lambdawas evaluated in E1 (lambda () (set! n (+ n 1)) n) | E1

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

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

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

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

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

  26. 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 theframe that was active when the lambda was evaluated • this effect can be used to store local state

More Related