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


    Date: 17 Feb 86 13:45:54 PST (Mon)
    From: willc%tekchips%tektronix.csnet at CSNET-RELAY.ARPA

    No, no.  Self-evaluation of numbers and strings is also unnecessary, so
    no intermediate position can be justified by Occam's razor or any other
    principle.  It is important that we acknowledge the lack of a principled
    justification, because some of us can be stubborn and downright ornery
    if we think we're arguing about principles rather than personal tastes.

OK, I freely admit it: I'm making arguments based not on principle but
on taste.  And, as everyone knows by now, I am both ornery and stubborn,
no matter what I'm talking about.

The principled position which I would have liked to take, of making
NOTHING self-evaluate (except (let ((x '`(let ((x ',x)) ,x))) `(let ((x
',x)) ,x)) and things of that ilk), is out of the question, since it would
be a grossly incompatible change, besides being politically doomed.

      It is true that distinctions become arbitrary here, but in each case we
      can apply judgement the same way that we applied judgement in the
      inclusion of any language feature....

    Exactly right.  I'd be happy with the judgment of the RRRS on this matter
    if it were made internally consistent, and I think most others would also.

Maybe you misunderstood me; I meant to argue that each different
expression type (vector, character, etc.) should be considered on its
own merit, and that it didn't make much sense to come up with a general
rule to decide all such questions; they don't necessarily have anything
in common with each other.  (The term "self-evaluation" is really
inappropriate to our description method anyhow, which takes pains to
distinguish objects from expressions.)  But I won't press this point.

Apparently I need to find a way to construe my desire that numbers,
strings, and characters self-evaluate, and vectors and () not
self-evaluate, as being internally consistent.  (I never wanted #!true
or #!false to self-evaluate, but won't fight a decision that's already
been made.)  I think you're asking for an awful lot, certainly not
something that has been achieved elsewhere in the language design.  But
before arguing further against your terms of argument (which I'll try
next if this attempt fails), let me hazard one more attempt at internal
consistency:  "Atomic" objects (other than symbols) self-evaluate, and
"composite" objects don't.  For present purposes "composite" objects
comprise vectors and lists, and lists include ().  Since we haven't
established a meaning for vectors or (), they are not (yet)
syntactically valid expressions, much less self-evaluating ones.

"Random" objects don't much bear on this discussion because they don't
have external syntax, and the language has neither EVAL nor macros.  But
if there were any way to evaluate or compile an unreadable object, I
think we all agree that the appearance of one within a program would be
an error.