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

Re: time of evaluation

        There's no reason that this solution, or any other internal
        implementation technique used in a Lisp system, should be cast in
        concrete for everyone.  It's important to distinguish between the
        defined semantics of Common Lisp, and implementation techniques.

However, if there are mechanisms being used to support side-effect-free (or at
least "reduced side effect") file compilation, it would be nice if there were
a portable interface by which those mechanisms could be accessed by language
extensions (for example, object oriented programming extensions).

It would also be nice if those mechanisms were as effective as we know how to
(portably) make them.  For example, I believe a side-effect avoiding mechanism
should have the following properties:

  1. It should distinguish forms being compiled from forms being
     interpreted during compilation (e.g., because the compiler is
     interpreted, or because a macro expansion function is interpreted, or
     because a break loop was entered).  Only a form being compiled should
     look in a special place for macro definitions, for example.

  2. It should distinguish between different invocations of compile-file,
     as might arise if one compile-file entered a break loop and the
     user started another compile-file while the first was still active.

We might be able to standardize on minimum requirements for a mechanism for
"reduced side-effect compilation".  If the requirements are reasonable, we
might also be able to standardize on that mechanism being used by default,
with options provided to select other (nonstandard) techniques, as has been