if ($part == 3) {
echo "Items in blue will be (re-)written in Part $part.";
} else {
echo "Items in blue will be written in Part $part.";
}
if ($part > 1) {
echo "
Items in green were written in previous parts.";
}
function p($n) {
global $part;
if ($n < $part) {
echo "green";
} else if ($n == $part) {
echo "blue";
} else if ($n == 23) {
if ($part < 2) { echo "black"; }
else if ($part > 3) { echo "green"; }
else { echo "blue"; }
} else {
echo "black";
}
}
?>
NOTE: Items to be written in Part 6 will not be 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 |
>(empty-frame? frame) | tester : returns #t if frame is empty; #f otherwise |
>(first-binding frame) | selector : returns the first binding in frame |
>(rest-of-bindings frame) | selector : returns the rest of the bindings in frame |
>(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 | representation of an empty 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 |
>(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 a binding for var bound to val in the first frame of env (or report an error if a binding already exists) |
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: 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: 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: cond | |
>(cond? exp) | tester : returns #t if exp is a cond expression; #f otherwise |
>(first-cond-exp exp) | selector : returns first conditional in cond exp |
>(rest-of-cond-exps exp) | selector : returns remaining conditionals in cond expression |
>(eval-cond exp env) | controller : evaluate cond expression |
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 |