Issue: QUOTE-MAY-COPY (Version 2)

[Kent M Pitman <KMP@STONY-BROOK.SCRC.Symbolics.COM>]

I asked Moon about his feelings on this. He thinks pretty strongly that
the ALWAYS option is the only practical one to pursue. Partly, he says,
because it's maximally compatible with current practice and partly
because it avoids making COMPILE-FILE seem different.
    
I personally don't put a lot of stock in the issue of COMPILE-FILE being
different. There are many `axes of consistency' that you can look at here,
and depending on how you look at it, you weigh things differently.

I do, however, concur with his assessment that it's compatible with
current practice, and I guess I have to admit that in the end that may
have to be the overriding consideration.

However, my support for ALWAYS is somewhat conditional. The subsequent
paragraphs embody my view to date on this issue:

 In principle, I favor option ALWAYS, permitting copying of quoted 
 structure to a constants area in any of EVAL, COMPILE, or COMPILE-FILE
 situations, as appropriate to the implementation.
    
 It should not be concluded from this that I favor restrictions on the
 kinds of data which may be quoted, however. The wording of option ALWAYS
 should be ammended to say that such copying is permitted only when the
 system can reliably deduce whether such copying is `appropriate,'
 and avoid it in cases where it is not. The purpose of such wording would
 be to avoid placing restrictions on what kinds of structures a user can
 or cannot quote.
    
 So, for example, if an implementor cannot in some context figure out how
 to detect circularities in quoted structure in order to either decline
 copying or correctly copy the circular form, then the implementation is
 not permitted to attempt copying in such contexts.
    
 Note however that because of special considerations forced by the external
 representation of data in compiled files, I go along with (and encourage)
 the establishment of a known subset of types which can be quoted (or used
 as self-evaluating constants) in code to be reliably processed by the file
 compiler. Coincidentally, such restrictions might make it easier for an
 implementation to know whether copying was going to succeed in the case of
 loading compiled code from a file, but technically these restrictions are
 not motivated by any consideration of what kinds of structures might or 
 might not be possible to QUOTE.

 My inclination is also to believe that copying should not be done
 repeatedly, and we should find a way to express this. That is, repeated
 execution of code in the same execution environment should return an EQL
 result (or some such). This is important to guaranteeing efficiency. Even
 in copying implementations, it is not necessary that such constants be
 allocated in a  read-only area or some such to achieve this effect. For
 example, quoted structure could be placed in a special array and QUOTE 
 could be implemented using AREF. What is important is that any of these
 permissions we give for copying not be taken for a license that QUOTE
 should be implemented by COPY-TREE or some other operation which cannot
 be done in constant time.