[t] means that this is trivial.
[i] means that this is an improvement: the original is correct, but
the correction clarifies the text or makes an improvement.
[e] means that this is an error: the original is incorrect in a way
that could cause confusion for the reader.
[r] revision, but what was there was not necessarily in error.
2 N D - P R I N T I N G E R R A T A
[t]Ch 2: Pg 64: Ln 3: "variable" --> "symbol"
[i]Ch 2: Pg 68: Lns 6:
"it uses amortized constant time -->
"each operation uses amortized constant time"
[i]Ch 2: Pg 52: Figure 2.2: Ln 3: -->
[e]Ch 3: Pg 105: Lns 15 and 16: p(a) ==> (p a)
[t]Ch 4: Pg 125: Ln -5: delete "we define"
[e]Ch 4: Pg 128: Ln -5:, replace "and ..." with
and if it is given $n$ arguments of types $t_1$, \dots,
$t_n$, and returns a value, then the return value is of type $t$.
[e]Ch 4: Pg 129: (not installed)
Our goal is to write a procedure \f{type-of-expression} which, given
an expression (call it {\it exp}) and a \emph{type environment} (call
it \tenvnic) mapping each variable to a type, assigns to {\it exp} a
type $t$ with the property that:
\vbox{
\begin{quotation}\noindent
Whenever {\it exp} is evaluated in an {environment} in which
each variable has the type specified for it by {\it tenv}, one of
the following happens:
\begin{itemize}
\item the resulting value has type $t$
\item the evaluation does not terminate
\item the evaluation fails on an error other than a type error
\end{itemize}
\end{quotation}
}
Another way of writing the permissible outcomes is:
\begin{quote}
The evaluation does not cause a type error, and if it returns, it
returns a value of type $t$.
\end{quote}
[t]Ch 5: Pg 196: Ln 23: "superclass class" ==> "superclass"
[e]Ch 6: Pg 207: Ln 2: delete the 1
[t]Ch 7: Pg 249: Figure Caption: eval-rand ==> eval-rands
[i]Ch 7: Pg 297: Ln -12: Otherwise, it calls \f{match-term} to try to
solve the first goal.
==>
Otherwise, it applies the current substitution
to the first goal. It then tries to solve
the resultant goal in \f{match-term}.
[i]Ch 7: pg 298: Ln 5: (car goals) ==> (subst-in-term (car goals) subst)
Ln 22: becomes (unify-term head goal)
and the line is move up.
Ln -3 It then applies the current substitution to the
goal term and attempts to unify the result with
the head of the freshly instantiated rule.
==>
It then attempts to unify the goal with the head
of the freshly instantiated rule.
[n]Ch 7: pg 298: Necessary for third printing.
[t]Ch 8: Pg 326: Exercise 8.19.2:
"instead of symbols." --> "instead of symbol,"
ERRATA FROM 1ST PRINTING CORRECTED IN 2ND PRINTING:
---------------------------------------------------------------
[t]Acks: Pg xvii: Add two names at the end of the first paragraph.
---------------------------------------------------------------
[t]Ch1 Pg 11: Ln -7: "In the previous example," --> On page 10,"
[t]Ch1 Pg 12: Delete 2nd para after display.
[t]Ch1 Pg 12: 3rd papr after display: delete "typical kind of"
[t]Ch1 Pg 14: Definition of nth-elt: add .~% before closing double quote.
[t]Ch1 Pg 14: Para -1: Ln -4: Insert sentence before "After"
A ~% is treated as a new line.
[i]Ch1 Pg 27: Exercise 1.18.2: Ln 9 and Ln 11 become
(compose (compose car cdr) cdr)
(compose (compose (compose (compose car cdr) car) cdr) cdr)
[t]Ch1 Pg 37: Add "; 1998" to Sussman and Steele reference.
[t]Ch1 Pg 38: due to the change on page 37.
---------------------------------------------------------------
[t]Ch 2: Pg 40: The n's on the lhs of the display are in the wrong font.
[t]Ch 2: Pg 41: The n on the rhs of the display under Unary
Representation is in the wrong font.
[t]Ch 2: Pg 44: Ln -12: rightmost * should be a +.
[t]Ch 2: Pg 45: Ln 8: Delete space between "description" and "-"
[t]Ch 2: Pg 51: Delete last sent of first paragraph.
[t]Ch 2: Pg 53: exercise 2.10: Replace 1st sentence of paragraph
following definition of fresh-id by
"Complete the implementation of fresh-id by defining all-ids,
which finds all the symbols in a lambda calculus expression
(page 49).
[t]Ch 2: Pg 53: exercise 2.11: 1st para becomes:
Extend the datatype definition on page 48 to
add the constants 3, *, and +. Then extend
parse-expression and unparse-expression to
support this enhancement.
[i]Ch 2: Pg 54: exercise 2.11: Lns 9-10 are replaced by
(lambda-exp (id body)
(if (eqv? id subst-id)
exp
(lambda-exp id (subst body))))
[i]Ch 2: Pg 58: Ln 24: Replace
"those we are about to describe" by
"those we describe in sections 2.3.3 and 2.3.4."
[i]Ch 2: Pg 58: Move paragraph at the bottom of page to before exercise 2.15.
[i]Ch 2: Pg 59: --> twice.
[t]Ch 2: Pg 61: Ln 1: "3. Define the observers (i.e., apply-procedures) for"
instead of
"3. "Define the apply -procedure for"
[i]Ch 2: Pg 62: in definition of apply-env
(let ((pos (list-find-position sym syms))) ...) -->
(let ((pos (rib-find-position sym syms))) ...)
[i]Ch 2: Pg 62: add (define rib-find-position list-find-position) below apply-env
[i]Ch 2: Pg 62: insert "We replace \f{list-find-position} by \f{rib-find-position}
to emphasize this new representation."
[i]Ch 2: Pg 63: in definition of apply-env
(let ((pos (list-find-position sym syms))) ...) -->
(let ((pos (rib-find-position sym syms))) ...)
[i]Ch 2: Pg 63: 1st sent. of exercise 2.23 becomes
A simpler representation of environments would be a single
rib consisting of a list of symbols and a list of values.
[i]Ch 2: Pg 64: Exercise 2.24 has been revised to
Define a substitution to be a function from the set of Scheme
symbols to the set of terms (exercise 2.13). The interface
for substitutions consists of (empty-subst), which maps each
symbol to the corresponding var-term (sometimes referred to
as its trivial association); (extend-subst i t s), which
returns a new substitution like s, except that symbol i is
mapped to term t; and (apply-subst s i), which returns the
value of symbol i in substitution s. Implement the data type
of substitutions with both a procedural representation and an
abstract syntax tree representation. Then implement a procedure
subst-in-term that takes a term and a substitution and walks
through the term replacing each variable with its association
in the substitution, much like the procedure subst of section 1.2.2.
Finally, implement subst-in-terms that takes a list of terms.
[i]Ch 2: Pg 64: Last sent of exercise 2.25 is replaced by
"There may be many such unifiers. If so, there will always
be one that is the most general."
[t]Ch 2: Pg 67: Lns 10-26: Indent one space right; Lns 27-29: one space left.
[i]Ch 2: Pg 68: Lns 5-6: Replace 1st sent. with.
"The code in figure~\ref{fig:queue-adt} has a useful but non-obvious
property: it uses amortized constant time."
[t]Ch 2: Pg 68: Ln -9: Replace '"consconstructs' with 'constructs'.
[t]Ch 2: Pg 68: Ln -5 add "; 1998" to Reynolds 1972 reference.
---------------------------------------------------------------
[t]Ch 3: Pg 72: exercise at the bottom of page:
"Cosider" --> "Consider" and "example" --> "expression"
[e]Ch 3: Pg 76: Ln 9 of grammar-3-1: (id) --> (identifier)
[t]Ch 3: Pg 76 (code for scanner should be in eopltt.)
[e]Ch 3: Pg 77: Ln 10 of Figure 3.4 should be
(program-to-list (scan&parse "add1(2)"))
[t]Ch 3: Pg 81: exercise 3.11: change 1st sentence to
Add numeric equality, zero-testing, and order predicates equal?,
zero?, greater?, and less? to the defined language's
set of primitive operations.
[t]Ch 3: Pg 101: exercise 3.37: Ln -2: "Why" --> "In what way"
[t]Ch 3: Pg 102: exercise 3.38: changes to
"What is the constructor in the interface for references?"
[t]Ch 3: Pg 105: Ln 7: Scheme array --> Scheme vector
[t]Ch 3: Pg 106: Exer: 3.45: "special form" ==> "form"
[e]Ch 3: Pg 108: Ln 15: change store to new-store
was (an-answer 1
(extend-store (apply-env env id) val store))
becomes
(let ((c (apply-env env id)))
(an-answer 1 (extend-store c val new-store)))
[t]Ch 3: Pg 117: Exercise 3.57 becomes a one star and
If the sixth line of \f{eval-thunk}
(figure 3.20) were deleted, what kind of interpreter would we get?
[t]Ch 3: Pg 117: delete "call-by-name and" from figure caption.
[t]Ch 3: Pg 118: delete "call-by-name and" from figure caption.
[t]Ch 3: Pg 120: 6 sets of braces ({,}) are too large.
[t]Ch 3: Pg 121: (braces too large on compound statement.
[i]Ch 3: Pg 123: last full line should be
(extend-env ids (map (lambda (id) 0) ids) env)))
instead of (extend-env ids ids env))).
----------------------------------------------------------------
[t]Ch 4: Pg 125: Ln 2: italic etc --> roman etc.
[t]Ch 4: Pg 130: Just before first display "tenv:" becomes
"tenv. Using the <> notation of section 3.5, we write"
[t]Ch 4: Pg 131: Ln -13 -10 -6 -4 "bound variables" --> "formal parameters"
[t]Ch 4: Pg 132: Exercise 4.1 is replaced by
Using the rules of this section, write derivations that assign types
for proc (x) x and proc (x) proc (y) (x y). Use the rules to
assign at least two types for each of these terms. Do they have the
same types?
[t]Ch 4: Pg 132: Ln -7 "bound variables" --> "formal parameters"
[i]Ch 4: Pg 135: Ln 3: (or (equal? t1 t2) --> (if (not (equal? t1 t2))
then shift left two spaces the next 5 lines.
[t]Ch 4: Pg 138: Ln 3 & 8: tenv-for-rands --> tenv-for-body
[t]Ch 4: Pg 141: Exercise 4.7: Lns 1, 2, 4, 16, and 17 "(pair" => "(pairof"
At the end of the exercise add:
Note: in SLLGEN, the production for \f{pair-type-exp} must be written as
(type-exp ("(pairof" texp texp ")") pair-type-exp) to avoid an LL(1)
conflict with \f{proc-type-exp}.
[e]Ch 4: Pg 142: Exercise 4.8: Ln 1: "list type" --> "listof type"
Lns 2, 4, 18, 20, 21, 22, 24 "(list" --> "(listof"
Insert new sentence at Ln -5:
"Use a trick similar to the one in exercise 4.7 to avoid
conflict with \f{proc-type-exp}."
[t]Ch 4: Pg 152: Exercise 4.11: expand-tenv --> extend-tenv
[e]Ch 4: Pg 153: Ln 3: Ln 6: 1 --> true and 0 --> false
[e]Ch 4: Pg 153: Ln 14: Ln 17: 1 --> true and 0 --> false
[e]Ch 4: Pg 153: Ln 22: Ln 25: 1 --> true and 0 --> false
[t]Ch 4: Pg 155: Ln 5: Delete two spaces before "type?"
[i]Ch 4: Pg 157: Lns 10 through Ln 28
Finally, when typing a proc expression
proc(t_1 x_1 ... t_n x_n) exp in tenv, we must have
(type-of-expression <> tenv) =
(t_1 * ... * t_n
->
(type-of-expression <> [x_1 = t_1, ..., x_n = t_n]tenv))
So to deduce the type of an expression, we introduce a type
variable for each occurrence of ? and for each
application, and write out an equation for each compound expression
using the rules above. Since we type each subexpression in exactly
one type environment, we can write exactly one equation for each
compound expression, and we don't need to worry about the different
values of tenv.
Then all we have to do is solve the resulting equations for these type
variables. The code solves these equations by calling
check-equal-type!, but we first consider how to solve these
equations by hand.
As an example, consider proc(? f, ? x)(f +(1,x) zero?(x)).
Let's start by making a table of all the missing type expressions ?
and applications in this expression, and assigning a type
variable to each one. Here we write f to indicate the ?
associated with the bound variable f.
[i]Ch 4: Pg 159: Ln 7: added "(See exercise 2.25.)"
[i]Ch 4: Pg 159: Ln 9: proc (f, x) ... --> proc(? f, ? x) ...
[i]Ch 4: Pg 159: Lns: Starting at "Let us consider ..." as Ln 1:
2 (twice), 5 (twice), 9. 10, 12, 14 "(list" --> "(listof"
[i]Ch 4: Pg 160: Exercise 4:16
Ln 1: is replaced by "Consider the following examples."
Ln -2 to end of exercise is replaced by:
First, insert ? in front of each formal parameter. Then,
solve the resultant type equations. Treat add1 as if it
were a procedure of type (int -> int) and + as if it were
a procedure of type (int * int -> int).
[e]Ch 4: Pg 164: Next-to-the-last para: replace everything after the
first two sentences by this:
If \ty is a procedure type, then we recur on the argument types and
the result type. If \ty is itself a type variable, then we check to
see if it contains a type. If it does, then we recur on its contents.
Otherwise, we check whether it is the same variable as \tvar. If it
is, an error is reported; if not, the procedure returns with an
unspecified value. (See figure~\ref{fig:checknoocc}.)
[e]Ch 4: Pg 165: the tvar-type clause in check-no-occurrences!
is changed to this:
(tvar-type (num vec)
(if (tvar-non-empty? ty1)
(loop (tvar->contents ty1))
(if (eqv? tvar ty1)
(raise-occurrence-check tvar ty exp))))
[i]Ch 4: Pg 166: because the paragraph above was longer than
the one it replaced, we ended up moving two exercises to this
page. (No real change, though) and added a new exercise:
The procedure \f{check-equal-type!}\ attempts to
unify its arguments $t_1$ and $t_2$, much like the procedure
\f{unify-term} in exercise~\ref{exer:unify}. In
\f{check-equal-type!}, the substitution is represented by the contents
of the type variables. Rewrite \f{check-equal-type!}\ to represent
the substitution explicitly, in the style of exercise~\ref{exer:unify}.
The resulting version of \f{check-equal-type!}\ should not use any side
effects.
[t]Ch 4: Pg 167: added because of the new exercise.
------------------------------------------------------------------------
[t]Ch 5: Pg 172: Ln -10: "Thus use" --> "Use"
[i]Ch 5: Pg 181: in definition of eval-program : (init-env) --> (empty-env)
[e]Ch 5: Pg 192: in code for elaborate-class-decls!
Add the line (initialize-class-env!) before (for-each ...).
[i]Ch 5: Pg 192: Ln -3 "Here the roll-up operations" -->
"Here the field roll-ups"
[i]Ch 5: Pg 196: in code for merge-methods
"(if overriding-method ...)" --> "(if (method? overriding-method) ...)"
[i]Ch 5: Pg 199: Exercise 5.11: Ln 1:
instanceof(exp,class-name) --> instanceof exp class-name
[i]Ch 5: Pg 200: Revised exercise 5.14
added "=" to the right of "id" in grammar of fieldset.
[i]Ch 5: Pg 200: Revised exercise 5.16
"Add expressions \f{superfieldref} {\it
field-id} and \f{superfieldset} {\it field-id} = {\it exp} that
manipulate the fields of \f{self}. Remember \f{super} is static."
[t]Ch 5: Pg 203: Exercise 5.30: "method vector" --> "method table"
--------------------------------------------------------------------------
[t]Ch 6: Pg 206: Ln -16 Delete the sentence
"This restriction can be enforced by a run-time check
whenever a new object is created."
[t]Ch 6: Pg 207: Ln 2: "method" --> "abstractmethod" (and delete the 1)
[e]Ch 6: pg 211: corrected definition of is-subclass?
(define is-subclass?
(lambda (name1 name2)
(or (eqv? name1 name2)
(and (not (eqv? name1 'object))
(is-subclass? (class-name->super-name name1) name2)))))
[i]Ch 6: Pg 211: add a new first bullet: "send a message to a non-object,"
[i]Ch 6: Pg 212: Ln 13: add "the value produced by" before "each".
[i]Ch 6: Pg 215: last paragraph
Delete ", since the ordinary class environment does not exist"
Add: "using the procedure \f{ensure-no-duplicates} to check that there
are no duplicate declarations in \f{m-decls}, and"
Just before: "using the procedure \f{statically-roll-up-method-decls}
[i]Ch 6: Pg 216: Ln 21: m-decls -->
(ensure-no-duplicates m-decls class-name)
[t]Ch 6: Pg 217: in code for statically-roll-up-method-decls.
delete self-name as argument to call of
of method-decl-to-static-method-struct.
[i]Ch 6: Pg 218: in code for method-decl-to-static-method-struct
delete self-name as a formal parameter. (see corr. Pg. 217)
[i]Ch 6: Pg 219: Lns 32,33: Wrap each in (type-to-external-form ...).
[i]Ch 6: Pg 220: delete "specifier" as a formal parameter in the
definition of typecheck-method-decl!.
[t]Ch 6: Pg 221: "~% --> " (remove the ~% from front of error
message in check-is-subtype!)
[t]Ch 6: Pg 223: Ln 13 and 14 were
this:
"Wrong number of arguments in expression ~s:"
" ~%expected ~s~%got ~s")
and become this:
"Wrong number of arguments in expression ~s:~%"
"expected ~s~%got ~s")
[t]Ch 6: Pg 225: in Ln 9 of type-of-method-app-exp was
this:
"~%Can't send message to non-object ~s in ~%~s"
and becomes this:
"Can't send message to non-object ~s in ~%~s"
[t]Ch 6: Pg 226: Lns 8 and 11 of type-of-instanceof-exp were
this:
"~%Unknown class ~s in ~%~s" name exp)))
"~%~s not an object type in ~%~s" ty exp)))))
and become this:
"Unknown class ~s in ~%~s" name exp)))
"~s not an object type in ~%~s" ty exp)))))
[t]Ch 6: Pg 227: Lns 20 and 25 of type-of-method-app-or-super-call were
this:
"~%Super call on abstract method ~s"
"~%Class ~s has no method for ~s in ~%~s"
and become this:
"Super call on abstract method ~s "
"Class ~s has no method for ~s in ~%~s"
[t]Ch 6: Pg 228: in code for type-of-cast-exp name1 is swapped with name2.
[e]Ch 6: Pg 228: Ln 11: ty --> name1
[t]Ch 6: Pg 228: Lns 10 and 14 of type-of-cast-exp was
this:
"~%~s incomparable with ~s in ~%~s"
"~%~s not an object type in ~%~s"
and become this:
"~s incomparable with ~s in ~%~s"
"~s not an object type in ~%~s"
[t]Ch 6: Pg 228: Ex. 6.11: Next-to-the-last sentence:
"pair types" --> "pair of types"
[t]Ch 6: Pg 230: Ln 2: "method vector" --> "method table"
[t]Ch 6: Pg 230: Ln 5 after code display: "vector" --> "table"
[t]Ch 6: Pg 231: Ln 3: "sytnax" => "syntax"
[t]Ch 6: Pg 234: Lns 22, 30, 31 of translation-of-method-app-exp were
this:
"~%Shouldn't have gotten here: Class"
"~%Shouldn't have gotten here:"
" Can't send message to non-object"
and become this:
"Shouldn't have gotten here: Class "
"Shouldn't have gotten here: "
"Can't send message to non-object"
[t]Ch 6: Pg 236: Ln 17 of translation-of-instanceof-exp was
this:
"~%Shouldn't have gotten here:"
and becomes this:
"Shouldn't have gotten here:"
[t]Ch 6: Pg 237: caption change: "Translating of cast" --> "Translating cast"
[t]Ch 6: Pg 237: Lns 15, 16, and 17 of translation-of-cast-exp were
this:
"~%Shouldn't have gotten here:"
" ~s incomparable with ~s in ~%~s")
"~%Shouldn't have gotten here:"
and become this:
"Shouldn't have gotten here: "
"~s incomparable with ~s in ~%~s")
"Shouldn't have gotten here: "
----------------------------------------------------------------------
[t]Ch 7: Pg 258: Ln -1: "languages," --> language implementations,"
[t]Ch 7: Pg 259: Ln -12: languages" --> "implementations of such languages"
[t]Ch 7: Pg 259: Ln -9: "languages" --> "language implementations"
[i]Ch 7: Pg 276: Exercise 7.22 is extended to become
Translate the interpreter of this section into
an imperative language. Do this three times: once using 0-argument
procedure calls in the host language, once replacing each 0-argument
procedure call by a goto, if it supports gotos, and once using
a switch statement inside a loop. How do these
alternatives perform as the computation gets longer?
[t]Ch 7: Pg 277: Ln 1: "languages" --> "language implementations"
[t]Ch 7: Pg 277: Ln 1: 260 --> 259.
[i]Ch 7: Pg 277: Added one sentence:
Utilize the fact that \f{apply-cont} is already a 0-argument
procedure, so there is no need to add an additional
\f{(lambda () \dots)} as in figure~\ref{fig:trampoline}.
[t]Ch 7: Pg 279: Ln 11: "Error" --> "Exception"
[e]Ch 7: Pg 281:
Ln 6: (eval-expression exp1 [n=1,l=(2 3)]env0 cont0)
Ln 10: where env2 = [loop=(closure (l) exp2 env2)][n=1,l=(2 3)]env0
Ln 18, 29: conditional --> conditionals
Ln 31, 34: wrap with (prim-args-cont <> ...)
[r]Ch 7: Pg 284-285:
Replace all but the first two paragraphs of page 284 and the
last two lines of page 285 with the following.
A thread is a computation in progress. There will be two kinds of
threads: runnable threads and completed threads. We represent a
runnable threads as a 0-argument procedure that returns a thread, and
a completed thread as an expressed value. When a thread comes to the
end of its continuation, it will return the next runnable thread from
the ready queue if possible, so a thread will return a completed
thread only once, when there are no more threads to run.
The basic constructor on threads is make-thread, which builds a
runnable thread. The procedure step-thread takes a runnable thread,
runs the thread for one step, and returns the resulting thread. We
will also need the tester completed? that checks to see if a thread is
completed.
(define make-thread (lambda (proc) proc))
(define step-thread
(lambda (runnable-thread) (runnable-thread)))
(define completed?
(lambda (thread) (not (procedure? thread))))
The ready queue is a global data structure with three operations:
initialize-ready-queue, which initializes the queue to empty;
place-on-ready-queue, which places a runnable thread on the ready
queue, and get-next-from-ready-queue, a 0-argument procedure that
removes a thread from the ready queue and returns it. If the ready
queue is empty, then the contents of the-final-answer, which will
always be a non-runnable thread, is returned. We create the ready
queue using the queue interface of section 2.4; we omit
the definitions of initialize-ready-queue and place-on-ready-queue,
which are routine.
(define the-ready-queue (create-queue))
(define get-next-from-ready-queue
(let ((empty? (queue-get-empty?-operation the-ready-queue))
(dequeue
(queue-get-dequeue-operation the-ready-queue)))
(lambda ()
(if (empty?) the-final-answer (dequeue)))))
Threads are scheduled for execution by a scheduler. The scheduler
takes a positive integer and a runnable thread, and returns the final
value of the computation. The integer specifies the number of steps
in a time slice. The runnable thread is immediately placed on the
ready queue. The procedure then enters an inner loop with two
arguments: the thread to be run (initialized by taking a thread from
the ready queue) and the number of ticks left in the time slice
(initialized to the quantum). If the thread is completed, it must be
the case that the computation has finished, and the thread is the
final value of the entire computation. Therefore this completed
thread, an expressed value, is returned. Otherwise the thread is
runnable. If there are no ticks left in the time slice, schedule is
called again, which puts this runnable thread back on the ready queue
and continues the computation. If there are ticks left, the inner
loop recurs, calling step-thread to advance the thread by one step and
decrementing the number of ticks remaining.
(define schedule
(lambda (quantum runnable-thread)
(begin
(place-on-ready-queue runnable-thread)
(let timer-loop
((thread (get-next-from-ready-queue))
(ticks quantum))
(cond
((completed? thread) thread)
((zero? ticks) (schedule quantum thread))
(else
(timer-loop (step-thread thread) (- ticks 1))))))))
[r]Ch 7: Pg 287: Ln 14: rhs of = becomes
(make-thread
(lambda () (get-next-from-ready-queue)))
[r]Ch 7: Pg 287: Ln 15-18: delete them.
[r]Ch 7: Pg 287: Ln 24: insert before Ln 24:
It also leaves its answer in the-final-answer, to become the
final answer of the computation.
[r]Ch 7: Pg 287: Ln -9: rhs of = becomes
= (make-thread
(lambda ()
(begin
(eopl:printf "final answer is: ~a~%" val)
(set! the-final-answer val)
(get-next-from-ready-queue))))
[t]Ch 7: Pg 287: Next to the last line: pgm5-1 --> pgm7-5-1.
[t]Ch 7: Pg 288: 1st para:
pgm5-2 --> pgm7-5-2
pgm5-3 --> pgm7-5-3
in exercise 7.3.3 pgm5-3 --> pgm7-5-3
[r]Ch 7: Pg 288: Exercise 7.36 (changed)
Represent a thread as a data structure containing
either a 0-argument procedure or an expressed value.
Then modify step-thread to check to see that its
argument is a legal thread.
[t]Ch 7: Pg 289: Titles of programs changed
pgm5-1 --> pgm7-5-1
pgm5-2 --> pgm7-5-2
pgm5-3 --> pgm7-5-3
[t]Ch 7: Pg 290: Lns 1, 4, and 7
pgm5-1 --> pgm7-5-1
pgm5-2 --> pgm7-5-2
pgm5-3 --> pgm7-5-3
[e]Ch 7: Pg 293: v --> val in the error messages
of release-cont and acquire-cont.
[i]Ch 7: Pg 298: In the definition of match-terms-against-rule, the first
argument to unify-term should be head, not (subst-in-term head subst),
although it is not an error, just less efficient, both
conceptually and in terms of execution.
[i]Ch 7: Pg 299:
"It then applies the current substitution to the goal term and
the head of the freshly instantiated rule, and attempts to unify
them." --> (because of the fix on Pg 299)
"It then applies the current substitution to the goal term,
and attempts to unify the result with the head of the freshly
instantiated rule."
[t]Ch 7: Pg 300: exercise 7.53. Add period after unify-term.
exercise 7.54 Replace last "?" by a period.
exercise 7.55 numeric valued --> numeric-valued
------------------------------------------------------------------------
[e]Ch 8: Pg 305: Revised Exercise 8.5
Extend the description on page 303 to include
the expression letinorder x1 = e1 x2 = e2
in e3. Here the scope of x1 is e2 and e3, and the scope
of x2 is e3, like the let* of Scheme.
[t]Ch 8: Pg 308: Ln 9: "calls" --> "names"
[e]Ch 8: Pg 311: Last line: fourth --> fifth
[t]Ch 8: Pg 312: Ln -4: "call --> "name"
[t]Ch 8: Pg 313: Ln 13: "call" --> "name"
[t]Ch 8: Pg 313: Ln 14: "call" --> "name"
[t]Ch 8: Pg 313: Ln -1(twice): "call" --> "name"
[e]Ch 8: Pg 316: The if expression is simple after the
first step, so since k is a variable, we must use C_simple-var.
It changes all but the first three lines of Figure 8.4
[e]Ch 8: Pg 318: Ln 1: (C_simple-var) --> (C_app)
[e]Ch 8: Pg 319: Ln 8: 307 --> 308
[t]Ch 8: Pg 321: Ln -11: Replace "several times" with "twice".
[t]Ch 8: Pg 326: Exercise 8.19.2 first sentence changed to:
This procedure takes an n-list, like an s-list (page 5), but
with numbers instead of symbols, and a number n and returns
the first number in the list (in left-to-right order) that
is greater than n.
[e]Ch 8: Pg 331: Ln -10: "in section 2.3.2 --> "earlier"
[t]Ch 8: Pg 333: Ln: last line of letrec rule. (font size in rhs rule)
[t]Ch 8: Pg 335: Ln: 4 (font size in rhs rule)
[t]Ch 8: Pg 337: Ln 2:
another type expressions --> another typed expression
[i]Ch 8: Pg 338: redefinition of cps-of-let-exp along
with a definition of cbindk that it uses:
(define cps-of-let-exp
(lambda (ids rands body k)
(let ((cont-exp
(let ((v-id (gensymbol "v")))
(proc-exp (list v-id)
(k (var-exp v-id))))))
(cbindk (cps-of-rands rands
(lambda (rands-res)
(let-exp ids rands-res
(cps-of-tail-pos body))))
cont-exp))))
(define cbindk
(lambda (exp cont-exp)
(let-exp (list k-id) (list cont-exp) exp)))
[t]Ch 8: Pg 339: Second and third bullet on page. (font size in rhs rule)
[t]Ch 8: Pg 339: Ln -8: "calls" --> "names"
[t]Ch 8: Pg 340: Second and third bullet on page
and K in setc expression on the first line following
that equation. (font size in rhs rule)
[e]Ch 8: Pg 341: Ln -6: setc x = v6 --> setc x v6
[t]Ch 8: Pg 341: K on rhs of equation on second bullet on page
and on K in the derefc expresion on the first
line following that equation. (font size in rhs rule)
[t]Ch 8: Pg 343: K on rhs of first equation; S_1 and S_2 on rhs 2nd
equation. (font size in rhs rule)
[t]Ch 8: Pg 343: Ln -2: "one subexpression --> "two subexpressions".
---------------------------------------------------------------
[t]App A: Pg 347 Ln -9 "is be" --> "is"
[t]App A: Pg 348 Ln 1 of grammar: Braces too large
[e]App A: Pg 349: Ln 13: surround line by left and right brace.
[t]App A: Pg 349: font size for scanner-spec-a is too large
[e]App A: Pg 350: Ln 5: The braces around the outside should be parentheses.
[e]App A: Pg 351: Ln 12: first "" --> "{" and second "" --> "}"
[t]App A: Pg 354: Ln 1: drop both apostrophes
[e]App A: Pg 354: Ln 4: Replace "begin" by "{" and "end" by "}".
[t]App A: Pg 354: Ln 7: Braces too large.
[e]App A: Pg 354: Ln 23: surround expression (in double quotes) by { and }.
[e]App A: Pg 355: Ln 11: "in z)" --> "in z" (drop ")" before double quote.
[t]App A: Pg 355: Ln 3 of grammar-a4, (Braces too large)
[t]App A: Pg 356: Ln 4, Ln 6, Ln 11, and Ln 13, grammar-a5 (Braces too large)
[t]App A: Pg 356: Midpage: "We will occasionally use
nested arbno's and separated-list's"
--> just drop both apostrophes.
[t]App A: pg 357: Ln 7: Braces too large.
[t]Bib: Pg 362: Clinger, Hartheimer, Ost Reference: delete "Journal of"
[t]Bib: Pg 365: Scott's reference should be "Pragmatics" not "Semantics"
[t]Bib: Pg 366: Add "Reprinted as (Sussman & Steele, 1998)."
[t]Bib: Pg 366: New ref:
Sussman, Gerald J. & Steele, Jr., Guy L. 1998. SCHEME: An Interpreter
for Extended Lmabda Calculus. Higher-Order and Symbolic Computation.
11(4), 405-439.
------------------------------------------------------------------------
[t]Index: Pg 368: amortized linear --> amortized constant
Pg 369: under bound : variable (drop 131)
Pg 370: completed
thread, 284 (added)
Pg 370: completed?, 284 (added)
Pg 372: delete "define" (line 1)
: delete "special form, 104"
Pg 372: deref, 101, 110, 116 --> 101, 111, 116
Pg 374: expval?, 110 --> 111
Pg 375: formal parameter ... 131
Pg 378: listof, 142, 159 (added)
Pg 380: pairof, 141 (added)
Pg 380: pair-type, 141 --> pair-type-exp, 141
Pg 382: ref-to-direct-target?, 110 --> 111
Pg 383: run-thread, 284, 288 (dropped)
Pg 383: runnable?, 284 (dropped)
Pg 383: scheduler, 284 ==> scheduler, 285
Pg 384: setref!, 101, 110, 116 --> 101, 111, 116
Pg 384: delete entry "special form"
Pg 385: step-thread, 284, 288 (added)
Pg 386: under thread: completed, 284 (added)
Pg 386: under time : amortized linear --> amortized constant
Pg 387: under type-exp: pair-type --> pair-type-exp
------------------------------------------------------------------------