user survey

[Jonathan Rees <Rees@YALE.ARPA>]

Your remarks on the following are requested.  Please reply to me
or to T-Discussion, not to T-Users.  The first two items concern
incompatible changes, the third a compatible extension.

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.  E.g.

        (LET-SYNTAX ((QUOTE (MACRO-EXPANDER (QUOTE X) `(LIST ,X))))
          (LET ((BAR 55))
            (LIST 'FOO (QUOTE BAR))))      =>       (FOO (55))

   The object which is the CAR of the list 'FOO will have a read/print
   syntax, so there needn't be any worry about writing forms to files.
   An open question is whether two-element proper lists whose CAR is
   this object should print with parentheses or a '; this is certainly
   permissible (it preserves READ/PRINT compatibility) but it might
   not be desirable.

   The disadvantage is that this is incompatible not only with all other
   Lisps but with T as documented by the T manual.

   How much of your code will break because of this?  Does this seem like
   a good idea to you?

2. The value of T.  The manual says nothing about what the value of
   T is, so this is actually a compatible change, but it is quite
   possible that there is user code which takes advantage of its current
   value.  Would you seriously object if T evaluated to a true object
   (and not necessarily a self-evaluating one) other than than the
   symbol T?  Does this seem like a good idea, or a gratuitous
   incompatibility?  Note that on success, predicate procedures would
   also return a different true value from what they're currently
   returning.

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.)

   Which alternative would you choose?