Potential issues?

[Jeff Dalton <jeff%aiai.edinburgh.ac.uk@NSS.Cs.Ucl.AC.UK>]

I am wondering whether it is worth raising / reviving the following
issues:

1. Read-case-sensitivity: It is difficult to make READ case-sensitive.
(Well, you might try defining lots of character macros, so perhaps it
is possible: hence the "difficult".)  Case-sensitivity is useful for
certain applications.  I should think something like a *READ-PRESERVE-
CASE* variable would be an appropriate solution.  Has this issue been
raised before?

2. Read-internal-case: Upper case is somewhat of an embarrassment these
days and is harder to read besides.  So it's a shame that Common Lisp
uses it internally.  *PRINT-CASE* can be used to hide the internal case
on output, but it still appears from time to time.  ExCL has (or had) a
way of dealing with this, so there is some precedent.  Nonetheless, I
suspect that any attempt to change the internal case would be doomed,
except for one thing: some trick along the lines of the canonical case
suggestion for pathnames could be used to aid conversion or to hide the
internal case for read as well as print.  One consequence is that, in
some setting, all upper case would mean all lower case (and vice versa),
but that may be an acceptable price to pay.

3. Proclaim-lexical: I seem to recall that this is an existing issue.
KMP's PRLCLAIM-SCOPE is related (since it would limit the scope of
special proclamations).

4. Hash-table-extry-extent: This refers to: <something like hash tables
except that entries could be removed if there was no reference to the
key except in such tables>.  This issue been discussed on the CL list
but has not (as far as I know) been raised as an actual suggestion for
change.  Note that such tables can be added with little work: since CL
does not require that there be a GC, it could just as well not require
that any entries actually disappear.  The main question is whether they
should be presented as hash tables or as something else.

5. Symbol-macro-flet: SYMBOL-MACRO-LET lets me have something that
looks like a variable but is really some expression.  It might seem
that MACROLET does the same for function names, but it doesn't.
MACROLET applies to entire calls, not just the name.  This suggests
that SYMBOL-MACRO-LET should have a companion, SYMBOL-MACRO-FLET.

For example:

     (symbol-macro-flet ((f '(g)))
       (list (f (a-list))
             (apply #'f (another-list)))

would be equivalent to:

    (list (funcall (g) (a-list))
          (apply (g) (some-list)))


BTW, what is the meaning of (MACROLET ((F () 'A)) #'F)?  In KCL and
Lucid, it seems to be the same as #'F without the MACROLET; but (F)
in the MACROLET is not the same as (F) without: this seems to be an
inconsistent interpretation of F.

-- Jeff