6001 structure

1
6001structure interpretation of computer
programsrecitation 15/ november 14, 1997
2
topics

• interpreters
• meta-linguistic abstraction
• eval and apply
• the environment model in code

3
puzzle for student presentation

• build a shell with history that works like
  this
• (define m (mk-shell))
• (m execute p) executes the procedure p and
  sets p to be the current proc
• (m back) sets the current proc back one
• (m forward) sets the current proc forward
  one
• (m run) executes the current proc
• hint
• use the circular buffer we designed last time!

4
meta-linguistic abstraction

• ways to build a big system
• break it into smaller pieces
• invent a new language
• why invent a new language?
• new way to think about the system
• tailored to the problem at hand
• code can be much more succinct
• examples
• the Unix shell
• Mathematica
• Excel spreadsheet macros

5
a very simple interpreter

• an arithmetic evaluator
• code
• (define (arith-eval exp)(cond ((pair?
  exp) (arith-apply (cadr exp) (arith-eval
  (car exp)) (arith-eval (caddr
  exp)))) (else exp)))
• (define (arith-apply op x y)(cond ((eq? op )
  ( x y)) ((eq? op ) ( x y)))
• sample run
• (define e (2 (3 4)))
• (arith-eval e) gt 14
• question
• what will arith-apply look like if there are lots
  of primitive ops?
• how could it be coded more elegantly?

6
essential idea recursive evaluation

• even in this trivial example we have
• the fundamental structure of a LISP interpreter
• recursive evaluation
• recall our rule for evaluation
• to evaluate a combination expression
• evaluate the subexpressions, and
• apply the value of the operator subexpressionsto
  the values of the operand subexpressions
• a primitive expression a number evaluates to
  itself
• and in the better version of arith-apply
• namely
• (define (arith-apply op x y)(apply (lookup op
  op-table) (list x y)))
• we have the notion of an environment
• (but a crude one its fixed!)

7
environments

• what does Scheme have that our arithmetic
  expression language doesnt?
• procedures
• variables and environments
• these are interwoven because
• environments are needed to execute procedures
• basic idea of parameter binding
• evaluate the body
• in an environment that has the parameters bound
  to the argument values
• lexical scoping
• recall that in Scheme
• a procedure carries with itthe environment in
  which it was created
• and the environment in which its body is
  evaluated is an extension of this environment
• this is not so essential (but its very nice)

8
an evaluator for scheme

• the code
• (define mc-eval (lambda (exp env)
• (cond ((number? exp) exp)
  base-case
• ((symbol? exp) (lookup exp env))
  base case
• ((eq? (car exp) 'quote) (car (cdr
  exp))) special forms
• ((eq? (car exp) 'cond) (evcond (cdr exp) env))
• ((eq? (car exp) 'begin) (evseq (cdr exp) env))
• ((eq? (car exp) 'lambda) (list 'proc (cdr exp)
  env))
• ((eq? (car exp) 'define) (evdefine (cdr exp)
  env))
• (else (mc-apply (mc-eval (car exp) env)
• (evlist (cdr exp) env))))))
• features to look out for
• the recursive structure where are the base
  cases?
• the call to mc-apply
• how procedures are represented
• how the environment is passed through

9
an applier for scheme

• the code
• (define mc-apply (lambda (fun args)
• (cond ((not (pair? fun)) (apply fun args))
  ground out
• ((eq? (car fun) 'proc)
• (mc-eval
  (car (cdr (car (cdr fun)))) procedure body
• (bind (car (car (cdr fun))) formal
  params
• args supplied args
• (car (cdr (cdr fun)))))) saved env
  (else (error '"Unknown function")))))
• features to look out for
• the recursive structure where are the base
  cases?
• the call to mc-eval
• how procedures are applied
• how the environment is passed through

10
playing with the interpreter

• evaluate these expressions
• 1
• ( 3 4)
• ( ( 3 4) ( 5 6))
• ((lambda (x) ( x x)) 3)
• ((lambda (x) (lambda (y) ( x y))) 3) 4)

11
filling in the details sequences

• how sequences are evaluated
• (define evseq (lambda (clauses env)
• (cond ((null? (cdr clauses)) (mc-eval (car
  clauses) env))
• (else (mc-eval (car clauses) env)
  (evseq (cdr clauses) env)))))
• can you add the and special form?
• definition
• to evaluate (and e1 e2 en)evaluate e1 to v1if
  v1 is false, the value is v1, else continueif
  all vi are true, value is vn
• code
• (define evand (lambda (clauses env)
• (cond ((null? (cdr clauses)) (mc-eval (car
  clauses) env))
• ((mc-eval (car clauses)
  env) (evand (cdr clauses) env)) (else f)))

12
filling in the details define

• code
• (define evdefine (lambda (body env) mutate
  the first frame
• (begin (set-cdr! (car env)
  (cons (cons (car body) (mc-eval
  (car (cdr body)) env))
• (cdr (car env))))
• (car body))))

13
meta-circularity

• this interpreter is
• a scheme interpreter
• written in scheme!
• can be viewed as
• a semantics we can read to understand how scheme
  evaluates expressions
• figure out where these features are evident in
  the code
• applicative order evaluation all the arguments
  of a procedure are evaluated before the call
• lexical scoping
• shadowing of variables

14
puzzle for student presentation

• implement an evaluator
• for a simple assignment language
• takes a list of statements
• a statement is either
• an assignment (var expr)
• or a print statement (print expr)
• hint
• use arith-eval
• modified to include a simple environment