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

Re: user survey

    1. Single quote read syntax:

Oy vay.   I  don't  THINK  I  have  any code that will break, but unless
there's some really compelling need to fiddle with it (I'm not impressed
by the ability to redefine QUOTE), I'd leave it alone.

    2. The value of T.

(At first I thought you were asking about the value of the T LANGUAGE!)

I have some code that depends on the fact that  T  evaluates  to  T  (or
more accurately,  is  GOING  to evaluate to true), which is wrong, since
you can  bind  T  to  NIL  or  3 or anything you like.  I could probably
change the code, but I think it's important that  the  logical  contants
have a  read-syntax, like numbers and strings.  Yes, we could use .TRUE.
and .FALSE.  but why bother?  I think it's a good idea to  leave  T  and
NIL alone.

    3. Semantics of LET.

(DESTRUCTURE (((A (B C)) FOO)) .  body)  is  really  peculiar  notation.
It's not  A,  B,  and  C  that are stored in a list structure, it's FOO.
But if we keep that idea, then I'd do away with DESTRUCTURE  and  notate
multiple-value bindings thus:

(LET (   (P          aaa)
         ((A B C)    bbb)
         ('(X (Y Z)) ccc)
         ('#(I J K)  ddd)   ) . body)

The first case is the standard one.

The second case is a generic multiple-value  assignment;  bbb  could  be
any sort  of  thing  that  "returned" three values.  We simply guarantee
that they'd be bound to A, B, and C, in that order.  The compiler  might
be able  to  do  great  things with this if it knew something about bbb.

The   other   two   cases   are   multiple-value   bindings   that   are
datatype-specific:  ccc must be a list structure (this is how you  could
notate DESTRUCTURE), and ddd must be a vector.

Except in  case  1,  you probably want to allow the value to be "longer"
than the variable-structure; e.g., we won't insist  that  (VECTOR-LENGTH
ddd) be  3,  although  it  shouldn't  be less than 3. Note that
(LET (( P  aaa)) ...)  would not be equivalent to
(LET (((P) aaa)) ...).

Note also that only in case 2 can we use anything other than a simple,
linear sequence of variables.

Unfortunately, the generic case (2)  doesn't  square  with  SET.   While
(SET P  aaa)  is  OK  now,  and  we could implement (SET '(X (Y Z)) ccc)
and (SET '#(I J K) ddd) to do what we want, (SET (A  B  C)  bb)  already
means something.  *sigh*

Finally, I'm  not  in  favor of the DEFINE/LABELS interpretation at all.
I don't  even  like  the triple-parenthesis notation in LABELS, but then
my Apollo prints ^ as the Greek letter lambda, so  I  tend  to  use  the
"long form."