CS37: The Structure and Interpretation of Computer Programs
Swarthmore College
Spring 2006

Interpreter Project
Summary of Major Functions


Items in red were written in previous parts.
Items in blue will be written in Part 4.
NOTE: Items to be written in Part 6 are not included here.

ABSTRACTION: binding
(make-binding var val) constructor : create a new binding with var bound to val
(binding-variable binding) selector : returns variable of binding
(binding-value binding) selector : returns value of binding
(set-binding-value! binding val) mutator : change value in binding to val
ABSTRACTION: frame
(make-frame vars vals) constructor : create a new frame with vars bound to vals
(first-binding frame) selector : returns the first binding in frame
(rest-of-bindings frame) selector : returns the rest of the bindings in frame
(empty-frame? frame) tester : returns #t if frame is empty; #f otherwise
(adjoin-binding binding frame) creates a new frame with binding added to frame
(binding-in-frame var frame) returns binding for var; #f if no binding exists
ABSTRACTION: environment
(empty-env? env) tester : returns #t if env is empty; #f otherwise
(first-frame env) selector : returns the first frame in env
(rest-of-frames env) selector : returns the rest of the frames in env
(set-first-frame! env new-frame) mutator : replace first frame of env with new-frame
(adjoin-frame frame env) creates a new environment with frame added to env
(extend-env vars vals env) calls adjoin-frame with a new frame (whose vars are
bound to vals) and env
(binding-in-env var env) returns the binding for var in env; #f if no binding exists
empty-env representation of an empty environment
(setup-env) returns a new global environment
global-env stores the global environment
IMPLEMENTATION: variables
(lookup-variable var env) returns the value of var in env; error otherwise
(variable? exp) tester : returns #t if exp is a variable; #f otherwise
HELPER: tagged-list?
(tagged-list? exp tag) tester : returns #t if exp is a list beginning with tag; #f otherwise
IMPLEMENTATION: quote
(quoted? exp) tester : returns #t if exp is a quoted expression; #f otherwise
(text-of-quotation exp) returns the text of a quoted expression
IMPLEMENTATION: define
(definition? exp) tester : returns #t if exp is a definition; #f otherwise
(eval-definition exp env) controller : define variable as specified in exp
(definition-variable exp) selector : returns variable portion of define exp
(definition-value exp) selector : returns value portion of define exp
(define-variable! var val env) add or mutate a binding for var bound to val
in the first frame of env
IMPLEMENTATION: set!
(assignment? exp) tester : returns #t if exp is an assignment; #f otherwise
(eval-assignment exp env) controller : assign variable as specified in exp
(assignment-variable exp) selector : returns variable portion of set! exp
(assignment-value exp) selector : returns value portion of set! exp
(set-variable-value! var val env) mutate the first binding of var found in env;
error if no binding exists
IMPLEMENTATION: evaluation
(i-eval exp env) controller : evaluates exp in env
(read-eval-print-loop) controller : read an expression from the user; evaluate; print result; loop
IMPLEMENTATION: application
(i-apply proc args) controller : evaluates procedures proc with arguments args
(application? exp) tester : returns #t if exp is a procedure application; #f otherwise
(operator exp) selector : returns operator (proc) of application
(operands exp) selector : returns operands (args) of application
(eval-operands operands env) returns a list of evaluated operands
(eval-application exp env) evaluates a procedure application
ABSTRACTION: primitive
(make-primitive name proc) constructor : creates a new primitive
(primitive-procedure? proc) tester : returns #t if proc is a primitive; #f otherwise
(primitive-name proc) selector : returns name of primitive procedure
(primitive-implementation proc) selector : returns implementation of primitive procedure
(apply-primitive-procedure proc vals) controller : apply primitive proc to evaluated arguments vals
IMPLEMENTATION: if
(if? exp) tester : returns #t if exp is an if expression; #f otherwise
(test-expression exp) selector : returns test expression of an if expression
(then-expression exp) selector : returns then expression of an if expression
(else-expression exp) selector : returns else expression of an if expression
(eval-if exp env) controller : evaluate if expression
IMPLEMENTATION: begin
(begin? exp) tester : returns #t if exp is a begin expression; #f otherwise
(begin-expressions exp) selector : returns list of expressions in begin exp
(eval-begin exp env) controller : evaluate begin expression
IMPLEMENTATION: cond
(cond? exp) tester : returns #t if exp is a cond expression; #f otherwise
(cond-clauses exp) selector : returns list of clauses in the cond expression
(clause-test clause) selector : returns the test expression in a cond clause
(clause-expressions clause) selector : returns the remaining expressions in a cond clause
(eval-cond exp env) controller : evaluate cond expression
(eval-clauses exp env) controller : evaluate list of cond clauses
IMPLEMENTATION: lambda
(lambda? exp) tester : returns #t if exp is a lambda expression; #f otherwise
ABSTRACTION: closure
(make-closure lambda-exp env) constructor : creates abstraction storing lambda exp and its env
(closure? exp) tester : returns #t if exp is a closure; #f otherwise
(procedure-parameters closure) selector : returns list of parameters of closure
(procedure-body closure) selector : returns list of expressions in closure
(procedure-env closure) selector : returns environment in which closure was defined
(apply-closure closure vals) controller : apply closure to evaluated arguments vals
IMPLEMENTATION: let
(let? exp) tester : returns #t if exp is a let expression; #f otherwise
(let->lambda exp) returns lambda expression equivalent of let expression
(eval-let exp env) controller : evaluates let expression
IMPLEMENTATION: let*
(let*? exp) tester : returns #t if exp is a let* expression; #f otherwise
(let*->let exp) returns let expression equivalent of let* expression
(eval-let* exp env) controller : evaluates let* expression