The interpreter
description
Transcript of The interpreter
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?