Re: macros, procedure->macro

[Dirk Herrmann]

On 10 Jul 2002, Marius Vollmer wrote:

> Dirk Herrmann <address@hidden> writes:
> 
> > True, but with current guile, how do you _access_ the local environment
> > (when not making use of acros, macros and mmacros to obtain it)?
> 
> I'm not sure, I understand the problem.  Currently, the evaluator
> carries around the environment in the "env" variable.  It will
> continue to do this, or?  From there, it can be passed to "acro" and
> "mmacro" transformers.

Yes, but we want to separate macro expansion, memoization and execution,
right? That is, we first have to get rid of acros and macros and even
mmacros from within the execution phase.  And, we want to not remove them,
but deprecate them first.  And, we still want to proceed with the
separation of expansion, memoization and execution while still keeping
acros and macros around as deprecated features.  That means, we will have
to provide a means to emulate the behaviour of acros etc. _without_ having
them being treated specially by the executor.  I thought it was for this
that you suggested making use of 'local-eval'.

Now, you are right that the evaluator carries around the env variable, and
passes it to acros, macros and mmacros.  But, after the handling of acros
etc. has been removed from the execution phase, we must find a different
mechanism for passing the env variable to the code emulating acros and
macros.  I am referring to your response cited below:

On 7 Jul 2002, Marius Vollmer wrote:

> Dirk Herrmann <address@hidden> writes:
> 
> > OK, lets assume we want to get rid of "acros" and "macros".  When should
> > that happen, and when should the corresponding functions be removed from
> > guile?
> 
> As soon as reasonable. :)
> 
> > Removing these would change the interface.  According to our
> > standard procedure, this would mean going through a phase of
> > deprecating the corresponding functions.  However, this would mean,
> > we could not actually proceed with working on the evaluator, since
> > as long as those functions exist (even if deprecated) it is not
> > possible to split up the evaluator.
> 
> Is it really impossible?  I'd say it can be done, as long as we have
> 'local-eval'.

Now, what I am basically saying is, that I don't understand how the
solution that you seem to have in mind should look like.  That is, I'd
like to see a code example where you demonstrate how you would use
local-eval to emulate acros and macros even after the evaluator is split
up into memoization and execution.

Or am I completely misunderstanding you?

Best regards,
Dirk Herrmann