[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

comments on revised Chapter 1

page 1-14, 4th paragraph:

The sentence "Implementations may choose to invoke
update-instance-structure under other circumstances as well" isn't
really true.   If the implementation decides to go through this process,
it always does both steps of the process, and it never just invokes
update-instance structure.

The other problem with that sentence is that it is buried in the middle
of the description of the two-step process itself.  

The paragraph should begin by making it clear that we guarantee this
two-step process happens in one circumstance (set of local slots in an
instance changes), and it might happen in other circumstances, but we
aren't listing here all the times when an implementation would decide 
to do this.

Here is a suggested rewriting of the beginning of the paragraph: 

"If a class is redefined in such a way that the set of local slots
accessible in an instance of the class is changed, a two-step process of
updating the instance takes place.    This two-step process can happen
in other circumstances, if the implementation finds it necessary.   For
example, some implementations might need to trigger this two-step
process if the order of slots in storage is changed."

page 1-15:  3rd paragraph

Delete the sentence "Implementations may choose to invoke class-changed 
under other circumstances as well."    This isn't true for class-changed.  

The first sentence states that the two-step process only happens under
certain circumstances.   This isn't right.   Perhaps the first step of
the process is only triggered under certain circumstances, but the
second step (calling class-changed) happens every time change-class is

page 1-15:

We should state that changing the class of an instance never affects
shared slots. 

page 1-17:  Figure 1-1

The column entries under "Class precedence list" aren't right; they
exclude the class itself from its own precedence list.   For example,
the CPL of array is (array t), not just (t).     I also think the CPLs
here should be lists (with parentheses), to be consistent with the way
CPLs are presented in "Determining the Class Precedence List".

page 1-31:

Still don't have the standard method combination listed under built-in
method combination types.  

page 1-41: third paragraph

There seem to be some spurious tildes (~) appearing in two of the forms.