The interpreter

Derived Expressions

(define derived? (lambda (exp) (or (if? exp) (function-definition? exp) (let?

exp))))

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)))))

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)))

Concrete derivation

Cont .

let

Function-definition

Reminder

Core (applicative-substitution)

• Language expressions– ASP

• The global environment– Data structures+core

• Values– Data structures+ core

• We will start with the data structures, that actually do most of the work

• Then the core – evaluation rules will be rather easy

Values

The Primitive-procedure ADT:1. Constructor make-primitive-procedure: Attaches a tag to

an implemented codeargument.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].

Usage

(User )Procedure

• (define (make-procedure pars body)(attach-tag (cons pars body) ‘procedure))

..…

Other values

(define (make-value x) (attach-tag (list x) ‘value))

Environment

frame

Initialization with primitives

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

Global-env constructor

Defining the global-env

(define the-global-environment (make-the-global-environment))

This expression is in the global scope of the interperter…

Selector:lookup

MUTATOR:add-binding!

Binding ADT

Using the environment

Eval-apply loop

(applicative-eval exp)(apply-procedure proc args)

Mutually recursive (why?)

eval

Eval-atomic

Lambda+definitions

If

application

Apply-primitive

substitute

“main” code of substitute

rename(exp)

“main” code of rename

Environment Model

• Formal algorithm

• Interpreter

Environment Model (Diagram)

Dynamic env-model

Interpreter for env. model

• What should be changed?

List of main changes

• ASP stays intact• Data structures: – Support an Environment ADT– Procedure ADT should include an environment pointer

• Core:– Every eval function 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.

env

lookup

Adding binding in global env

Core:eval

Every eval now has env argument

apply-procedure

apply-procedure (cont.)

Dynamic-env interpreter

• What would you change?