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


    Insofar as a valid Common Lisp expression which is not "it is an error"
    could work differently and unpredictably in one implementation of the spec
    and another, then the language isn't portable and "common" is a myth.

The language specification is full of explicit concessions to different
implementation techniques.  "(let ((x 5)) (eq x x))" is a program that could
yeild different results in different implementations (page 78).  If you want to
question the funny nature of EQ, feel free.  I think you'll come up against a
lot of opposition if you suggest that EQ be made to act like EQL.  We've had
that discussion before, I believe.

But the nature of EQ wasn't being questioned.  The choice of the predicate used
by Throw for comparing catch tags was.  I don't think there's any person living
that thinks Common Lisp is the best programming language ever invented.  There
are many people who think it's a good compromise between many different
language design issues.  One should be able to write a correct Common Lisp
program today and have it run tomorrow.  No, the language shouldn't be
stagnant, but it should change "only slowly and with due deliberation."

My point was that the Throw/EQ issue is a little thing, and there are many
other ugly little things in the language, but people have invested time and
money implementing them.  As I said, if it's agreed that EQL is the best way to
compare catch tags, then I'll go along with that decision.  But I wanted to
inject a little of the language's goal of stability into the discussion.  A
programming language that changes in subtle ways overnight is far worse than
one with subtlties that are carefully documented.