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 |