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


For what it's worth, in the original spec for the T dialect that I worked up
in 1981, "?" had an assigned pronunciation. It was explicitly stated that it
should be pronounced "pee". That way, when we said "zero?" out loud in
conversations with non-T-programmers, they would `accidentally' understand us.
After I left, someone (Jonathan?) took this out, probably thinking it was
gratuitous silliness, but in fact I agree with you that pronounceability is
very important to a language and that definition wasn't put there on a whim.
Along the same lines, "!" was given the pronunciation " destructively". 

Those who doubt that pronunciation is important should notice that most 
natural languages are transmitted primarily verbally (that is, that changes
in language are frequently best described at the acoustic rather than
written level), that psychologists seem to believe that indexing of objects
in the brain is done more on the basis of auditory rather than visual keys
(based on studies of how people mis-remember things), etc.

Those who insist that the morpheme "pee" is somehow less meaningful
than some other token that could have been chosen should ask themselves not
about how English words relate to Latin, but how the creators of Latin came up
with their morphemes.

I believe that a language which cannot conveniently be discussed allowed
[... uh, "aloud" I mean -- i guess I'll leave that typo in to support
my claim two paragraphs above] is doing its prospective programmers a great
disservice... but I think ZERO? looks lots nicer than ZEROP, so my vote is
for changing the pronunciation and leaving the written word as it is.

By the way, T also originally defined very carefully the rules of contraction
so that users would be able to choose consistent function names. It specified,
for example that a function xxx which did 
 (define (xxx . args) (apply fn EQ? args))
should be called fnQ, and that one that did 
 (define (xxx . args) (apply fn EQV? args))
should be called fnV and that one that did
 (define (xxx . args) (true? (apply fn args)))
should be called fn? .  In the case of a "?" ending up in the middle of a token,
it was to migrate to the end, and in the case of a "!" and "?" ending up in a token
(ie, a destructive predicate), the "?" was to precede the "!". Among other things,
this meant that the function which did (MEM EQ? x y) could be written (MEMQ x y)
and the function which did (MEM EQV? x y) could be written (MEMV x y). Further,
(TRUE? (MEM EQV? x y)) = (TRUE? (MEMQ x y)) = (MEM? EQ? (MEMQ? x y)) = (MEMQ? x y).

Personally, I am content to say that "?" does not get attached to any predicate
which has a root which contains no alphabetic characters. That is, that ">" is
allowed to be a contraction for "greater?" rather than just "greater", so ">?"
is like saying "greater??". We used a similar reasoning for not putting "!"
on the end of "SET" in T, since "SET!" is redundant. Any assignment is by
definition destructive and setting an "!" after SET is effectively redundant
and just makes code look ugly. I think the proponents of the name "SET!" would
say that assignments -should- look ugly, and to that I can only say that I

Sorry this message got as long as it did, but this is the sort of topic people
don't seem to be able to vocalize their feelings about, so I figured it was
worth doing so just for the record.