Re: user survey

[Douglas Baldwin <Baldwin@YALE.ARPA>]

        1. Single quote read syntax:  I would like to change the reader so 
           that 'FOO reads in as a two-element list whose CADR is FOO but 
           whose CAR, rather than being the symbol QUOTE, is an object known 
           to the evaluator as introducing a special form which has the 
           standard semantics of QUOTE.
        
           The advantage of this is that 'FOO will "work" even in environments 
           where the symbol QUOTE has a different meaning.

    (LET ...) won't work in an environment where LAMBDA has an unusual
meaning; why should ' and QUOTE be any different? From my point of view
this seems like a fairly unimportant change. It won't interfere with any
of my code, but if it did I would want to see very strong evidence that it's
going to be very useful to lots of other people before I stopped screaming
against it.

    
        2. The value of T.
    
    No complaints.


        3. Semantics of LET.  There are at least three camps regarding the 
           issue of what
        
                (LET (((A B) (FOO X))) ...)
        
           should mean:
        
           (a) It should be compatible with Common Lisp, so that LET and DESTRUCTURE
               are identical.  That is, it means
        
                    (LET ((TEMP (FOO X)))
                      (LET ((A (CAR TEMP)) (B (CADR TEMP))) ...))
        
           (b) It should be compatible with LABELS and DEFINE, more or
               less like Common Lisp's FLET construct.  That is, it means
        
                    (LET ((A (LAMBDA (B) (FOO X)))) ...)
        
           (c) It should be reserved for use in some kind of multiple-value-return
               mechanism, something like Common Lisp's MULTIPLE-VALUE-BIND.
               (The implementation of multiple-value returns is imminent.)
    
    If it integrates sanely with whatever notation you use for multi-valued
returns in other situations (e.g. in LAMBDA) then option (c) would seem to
be the right answer. If other uses of multi-valued returns involve a different
notation then (c) is clearly wrong because of the inconsistent notation.
If (c) is rejected then I would probably prefer (b) slightly over (a), though
it's hard to find convincing reasons why.