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

Remaining questions & remarks (2)

Almost no one answered my query about grandfathering.  Think about it
while answering the questions below.  I propose listing incompatibilites
in the "notes" section, and otherwise not worrying too much about the
incompatibilities we're introducing.  I'll send out a list of known
language changes in a separate message.

Here is the second list of remaining questions and remarks.  Some of
these may be duplicates.
1.  BEGIN vs. SEQUENCE: this is a pretty glaring ugliness in the report;
    it's obvious to the world we couldn't get consensus on this one.
    Many people have told me that they don't care which one is there, so
    long as there's only one.  SEQUENCE was used heavily in S&ICP and
    for that reason I think it should be retained; thus the options I
    offer are
      (a) leave things as they are (BEGIN essential with non-essential
	  synonym SEQUENCE),
      (b) remove BEGIN and make SEQUENCE essential (noting in the Notes
	  section that BEGIN, like #!TRUE etc., should be supported by
	  those implementations which care about running code written in
	  the past year).
    Let me know your vote if you haven't done so already.
2.  Similarly but less glaringly, we have a problem with the numeric
    comparisons.  Again, many people have said they don't care but they only
    want one set, with or without question marks.  Thus I offer
    the choices
      (a) leave things as they are
      (b) flush the alternative names  <? <=? >? >=? =?
    [The ones without question marks were used in S&ICP; moreover, they
    exist in other Lisp dialects.  The argument in favor of the ?'s is that
    it allows the simple statement: "names of predicates end in question mark".]
    Send me your vote.
    Again, I sense capitulation on the part of some who have been stubborn.
    The only options permitted are:
      (a) Keep both
      (b) Flush both
    My editorial sense is that we should be able to achieve (b).  Remember,
    the language also doesn't have EVAL, environments, or macros, so if you
    want to keep these features please say how they're different from other
    "indispensible" features that the language DOESN'T have.
    Many people have suggested removing these.  Anyone who wants them
    retained MUST provide a convincing rationale, for inclusion in the
    report.  Otherwise I'll remove them.
5.  Should we say anything about the possibility of parallel or
    interleaved argument evaluation?  Remembering something I thought I
    heard Will once say, I added the innocent little phrase "or perhaps
    in parallel" to the description of procedure calling.  Richard
    Kelsey quickly pointed out that if it's mentioned as being a
    possibly legal implementation, many otherwise valid scheme programs
    may fail to run in implementations which do this, because they won't
    do necessary synchronization.  I agree; this is acceptable only if
    we provide synchronization primitives. 
6.  Number input exactness: two proposals have been advanced to decide whether
    a number is exact or inexact if it has no #I or #E prefix and contains no
    trailing #'s.
      (a) Inexact if there are digits following a decimal point, or if exponential
	  notation is used.  Otherwise exact.  (This makes exctness similar to
	  "floatness" in CL.)
      (b) A proposal which Will advanced, which I'm unable to locate right now, so he'll
	  have to re-send it.
    I'll additionally advance another alternative, and you can make up more of
    your own:
      (c) Always exact.  E.g. "1.2" is exact.
7.  Must a port still be a port (i.e. answer true to INPUT-PORT? or OUTPUT-PORT?)
    after being closed?
8.  Apparently there's no difference between ABS and MAGNITUDE.  Should we
    keep both?  If so, should I change the presentation in any way?
9.  ANGLE is what Common Lisp calls PHASE; any interest in changing the
    name? ...
10. Two-argument arctangent (ATAN Y X) is unnecessary, since its effect
    can be trivially achieved by (ANGLE (MAKE-RECTANGULAR X Y)).  Do we
    apply Occam's razor and remove it?  If it's retained, then I'll just
    document it as being the same as (ANGLE (MAKE-RECTANGULAR X Y)).

11. JINX says: if PROCEDURE? exists, then a portable printer can be written.
    JAR replies (in jest):
      (define procedure?
	(lambda (obj)
	  (not (or (pair? obj) (null? obj) (symbol? obj) (number? obj) ...))))
    Seriously however, I was the only holdout at Brandeis against having
    this predicate.  After thinking about this further I think it's not such
    a bad idea, even though it is of limited use.  Is anyone opposed to
    having an essential procedure PROCEDURE?, to round out the set of type

12. (if x 1) vs.  (cond (x 1)) -- this is inconsistent, as a couple of people
    have pointed out.  I would expect these two expressions to have the
    same meaning, but they don't.  The first is defined to always return
    an unspecified value.  The second is defined to return the value 1
    if x is true, and an unspecified value otherwise.  I would like to
    make this consistent, and there are two ways to do.  Take your pick:
      (a) Change IF expressions so that they return the value of the
	  second form if the first form evaluates to false.
      (b) Change COND and CASE so that they return an unspecified value if
	  there is no ELSE clause.
    Here are some arguments in favor of (a):  
     - It removes the possibility of inferring that an implementation might
       not be tail-recursive through an alternate-less IF.
     - Similarly, it makes (IF #T <exp>) mean the same as <exp>, and removes
       doubt about the meaning of things like (if x (if y 1) z).
     - It simplifies the macro expansion of COND as compared with (b).
     - Option (b) is obviously undesirable (consider the case of mutually
       exclusive test expressions in a COND).

13. Many people would like to see the (define ((((a b) c) d) e) ...)
    feature go away.  S&ICP doesn't use it, and it has a rather complicated
    syntax (look at the BNF for evidence).  Vote keep or flush.

14. Status of LOAD not resolved.  If, as I suggested, LOAD is only
    to be syntactically valid at top level of a file, shouldn't it be
    renamed to be INCLUDE ?

15. Page breaks and tabs are mentioned in the report (actually I guess I
    added them - sorry), but there are no #\PAGE or #\TAB characters.
    Can this be made consistent by documenting #\PAGE and #\TAB, or
    should I try to neutralize or remove the places where I mention tabs
    and page breaks, by saying something to the effect that there may be
    other whitespace characters, and some of these characters might
    terminate comments?  In Common Lisp, #\PAGE and #\TAB aren't
    "standard", they're only semi-standard; and I don't believe that

16. If page breaks are documented, should the terminate comments?  I think
    they should (but of course they don't in Common Lisp).

17. Bartley says: "the second sentence of the description of EQUAL? should
    say that EQV? is used for all objects except pairs, vectors, and
    strings."  Forcing it to use EQV? seems kind of random to me.  This
    would of course make my notion of "apparent equivalence" useless,
    destroying what I deluded myself into thinking was an elegant symmetry
    between EQV? and EQUAL?; maybe it's a bogus idea anyhow.  I
    intentionally wanted to be silent on this point, allowing EQUAL? to
    return true more often than EQV? perhaps, but I don't care that much.


Presentation questions:

18. Several people have complained about Clinger's perhaps overly accurate
    description of what happens when variables become bound.  To be
    accurate, we have to say that locations are created and the initial
    value is stored in the location, but this doesn't sit well with the
    desire to have Scheme sound like an almost-functional language.
    What to do?
19. What should the dedication be?  Sussman suggested the PDP-6, which was
    the world's first Lisp machine, but some people didn't like this joke.
    I have changed it to Christopher Strachey in the draft.
20. Is it OK to replace "Lazy ML" with "SASL" (last paragraph of section
    0.0)?  This is Dan Friedman's suggestion and I approve; SASL is more
    widely known.  I've never heard of Lazy ML (although I can imagine what
    it is).
21. Should section numbers be zero-based?  I'm beginning to think this looks
    unprofessional; and it just doesn't look right in several places.  It
    worked well in the previous version of the report, and it's clearly more
    consistent with the language (which is zero-based), but it doesn't work
    the way I've reorganized things.  If you like zero-based section
    numbers, speak up.
22. Was Scheme the first programming language to have first-class lexical
    closures?  Can we say anything edifying along these lines?
23. I flushed the historical note "CATCH could be provided by a procedure"
    sentence (again, because two or three people thought it was random and I
    agreed), but some of you have complained about this.  Why should this
    bit of history be present, but not others that are at least as
24. CALL/CC was mentioned in a sentence in a rationale in the RRRS.  I
    flushed the reference because (a) a number of people find the name
    CALL/CC quite distasteful and (b) it is inconsistent to mention here
    that some scheme implementations provide an alternate name for this but
    not also do so for LABELS, BLOCK, and a zillion other things.
25. How best to resolve the inconsistencies between terminology in text and
    semantics?  Namely: "I", "Ide", "identifier" in semantics vs. "variable"
    in text; "Com", "command" in semantics vs. "statement" in text.
26. FORCE & DELAY are still problematic.  About half of respondents said it
    was better to put FORCE up front with DELAY, and the other half thought
    it was fine as it was.  No one gave convincing arguments.
27. Is 3.0.2 (description of procedure calls) a good place to take note that
    () is not a valid procedure call?
28. In section 0.0, 2nd paragraph, before the terms "variable" and
    "identifier" have been defined, it should say "variable" instead of
    "identifier" to be consistent with the rest of the report.  Is that OK?
29. There are two nonterminals in the BNF that need names.  Currently they
    are called <formals> and <formalz> which was never intended to be a
    serious suggestion (I put it there to see if anyone would actually read
    the BNF!).  Actually one or both of these can go away if NAMED-LAMBDA
    and/or (DEFINE ((( ...) ...) ...) ...) go away.  Can someone who likes
    these things take a look at the BNF and suggest names for these?
30. Someone wanted me to avoid discussion of immutable objects in the
    discussion of operational equivalence in the 2nd paragraph before entry
    for EQV? .  I want to mention immutability there because I think it's
    important to warn users that this might be the case, otherwise they can
    easily end up writing unportable code.


For your information, here are changes I've made that either don't seem
controversial or reflect what I judged to be the consensus:


Only one empty list, period.  (eq? '() '()) returns true.

Kelsey asks: why does ROUND round to even?  Answer: Common Lisp does it
this way.  Ask Steele.  Probably this has to do with statistical

A port does not become closed as a side effect of reaching end of file.
After end of file, you'll continue to read end of file objects as long
as the port is open.  It's an error to read from or write to a closed

DISPLAY writes characters like WRITE-CHAR does.



"Iterative process" --> "iterative computation" on page 3 (this change
is an example of "desussmanization").

Inserted the following sentence in section 1.0:
"In addition, \ide{+}, \ide{-}, \ide{1+}, and \ide{-1+} are identifiers."

At Dan Friedman's request, I removed Perlis from the list of authors.

Changed <? and >? to < and > in all examples.

Removed non-essential features from examples (including the big one)
where possible:  (1+ x) --> (+ x 1), (-1+ x) --> (- x 1), (define (foo
...) ...) --> (define foo (lambda ...)), 1-armed if --> cond, named let
--> letrec.

Changed variable name "loop" to "recur" in the
call-with-current-continuation example.

"iff" --> "if" in section 5.1.


That's all for now, folks...