[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
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
3. Semantics of LET. There are at least three camps regarding the issue
(LET (((A B) (FOO X))) ...)
(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?