The interpreter

1. The interpreter

2. Derived Expressions (define derived? (lambda (exp) (or (if? exp) (function-definition? exp) (let? exp))))

3. Shallow-derive (define shallow-derive (lambda (exp) (cond ((if? exp) (if->cond exp)) ((function-definition? exp) (function-define->define exp)) ((let? exp) (let->combination exp)) (else (error ’shallow-derive "unhandled derivation: ~s" exp)))))

4. Recursive derivation (define (derive exp) (if (atomic? exp) exp (let ((mapped-derive-exp (map derive exp))) (if (not (derived? exp)) mapped-derive-exp (shallow-derive mapped-derive-exp)))

5. Concrete derivation

7. Cont.

8. let

9. Function-definition

10. Reminder

11. Core (applicative-substitution) • Language expressions • ASP • The global environment • Data structures+core • Values • Data structures+ core

12. We will start with the data structures, that actually do most of the work • Then the core – evaluation rules will be rather easy

13. Values The Primitive-procedure ADT: 1. Constructor make-primitive-procedure: Attaches a tag to an implemented code argument. Type: [T -> Primitive-procedure]. 2. Identification predicate primitive-procedure?. Type: [T –> Boolean]. 3. Selector primitive-implementation: It retrieves the implemented code from a primitive procedure value. Type: [Primitive-procedure –> T].

14. Usage

15. (User) Procedure • (define (make-procedure pars body) (attach-tag (cons pars body) ‘procedure)) …..

16. Other values (define (make-value x) (attach-tag (list x) ‘value))

17. Environment

18. frame

19. Initialization with primitives

20. Before introducing the constructor: A word on mutation • So far we kept our code fully functional • That is, no state required • “define” is somewhat an exception, but mainly for convenience • Recursive function definition is an exception to that, can be done without define, but requires fixpoint operation • For implementing the global environment we want to be able to change bindings • A functional solution is possible but messy • We use an abstraction of mutation through the Box ADT of Dr. Racket • It basically “wrappes” the object and allows (sort of ) a “pointer” to it

21. Global-env constructor

23. Defining the global-env (define the-global-environment (make-the-global-environment)) This expression is in the global scope of the interperter…

24. Selector:lookup

25. MUTATOR:add-binding!

26. Binding ADT

27. Using the environment

28. Eval-apply loop (applicative-eval exp) (apply-procedure proc args) Mutually recursive (why?)

29. eval

30. Eval-atomic

31. Lambda+definitions

32. If

33. application

34. Apply-primitive

35. substitute

38. “main” code of substitute

39. rename(exp)

41. “main” code of rename

42. Environment Model • Formal algorithm • Interpreter

43. Environment Model (Diagram)

46. Dynamic env-model

47. Interpreter for env. model • What should be changed?

48. List of main changes • ASP stays intact • Data structures: • Support an Environment ADT • Procedure ADT should include an environment pointer • Core: • Every evalfunction gets an environment as an additional parameter • Uses it e.g. for lookup, and passes it on to recursive eval and apply calls • apply of user procedures (closures) change to manage envs.

50. env