[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Mr. Fry has begun our bimonthly discussion of EVAL-WHEN (on April 1,
no less). I think, however, that the case of (EVAL-WHEN (LOAD)
(DEFUN...)) is straightforward. When the book says that "the compiler
should arrange to evaluate the forms in the body when the compiled file
... is loaded", it means that the DEFUN should be evaluated to produce
its effect of stashing a function in the symbol's definition. I don't
think anyone meant to imply that the body of the DEFUN had to be
processed in any particular fashion (e.g., macroexpanding it at load
time). But I'll acknowledge that it's not precisely clear.
If you do want the DEFUN to be processed as if it was entered at
top-level, you might do the following, which will produce an interpreted
(EVAL '(DEFUN ...))
A related question is what to do with other sorts of top-level forms,
not DEFUNs or DEFMACROS. Some LISPs have a (perhaps secret) switch
which determines whether the compiler dumps anonymous compiled functions
or dumps the lists and interprets them at load time. There may be
demantic differences resulting from the choice.
A couple of other questions have been asked before and never really
answered. Are EVAL-WHENs allowed down in the guts of a function or
macro and what do they mean there? Also, would it clarify things if we
acknowledged the fourth EVAL-WHEN situation, that of the compiler
digesting a definition without actually evaluating it? This occurs, for
example, when the compiler sees a DEFMACRO. It doesn't evaluate it per
se, but it does digest it enough to be able to expand future macro calls.
It's not sufficient to say that DEFMACRO is a special case and the
compiler always looks at it, because the compiler doesn't look if it's
wrapped in an (EVAL-WHEN (EVAL) ...). This implies that there is some
secret situation that has been left out of the list.