Re: `eval'ing form in the current lexical environment

[Stefan Monnier <monnier@iro.umontreal.ca>]

> Aha, I wasn't aware that that situation was considered illegal.

It's pretty much incompatible with the notion of compilation:
Usually, when you compile code like

    (foo (bar))

under the assumption that `foo` is a function, the code you generate
evaluates (bar) before doing anything else.  So by the time it looks at
`foo` it's too late: if `foo` turns out to be a macro you'd have to
"undo" the evaluation of (bar).

IOW, you're forced to do something like what you suggested, i.e. replace
*every* function call with

    (if (is-a-macro 'FUN)
        (handle-the-corner-case 'FUN 'ARGS)
      (FUN . ARGS))

so the above ends up compiled as if you had written:

    (if (is-a-macro 'foo)
        (handle-the-corner-case 'foo '(bar))
      (foo (if (is-a-macro 'bar)
               (handle-the-corner-case 'bar nil)
             (bar))))

which kills all hopes of generating good-quality code.

You can admittedly do better by "watching" the definition of functions
and keeping dependencies, so when a function gets redefined as a macro
you can throw away all the compiled code which depends on it (and
recompile it later as needed).

Nevertheless, it's costly and not considered worth the trouble.

The reverse is accepted, OTOH: you can take a macro and later turn it
into a function.  Code compiled when it was defined as a macro will
simply keep using the old definition until it gets recompiled.


        Stefan