Re: Elisp lexical-let

[Andy Wingo <wingo@pobox.com>]

On Tue 21 Jul 2009 21:48, Daniel Kraft <d@domob.eu> writes:

> (defvar x 1)
> (defun foo () x)
> (lexical-let ((x 2))
>   x ; -> 2
>   (foo) ; -> 1
>   (setq x 3)
>   x ; -> 3
>   (foo) ; -> 1
>   (let ((x 4))
>     x ; -> 4?
>     (foo) ; -> 4
>     (setq x 5)
>     x ; -> 5
>     (foo) ; -> 5
>     ) ; end the let
>   x ; -> 3?
>   (foo) ; -> 4
>   )
> x ; -> 4
> (foo) ; -> 4

It's actually fairly simple, imo. Alpha-equivalence says that
(lexical-let ((x a)) x) is the same as (lexical-let ((y a)) y). (Note
that this lexical-let corresponds to Scheme's let.) So your program is
the same as:

> (lexical-let ((y 2))
>   y ; -> 2
>   (foo) ; -> 1
>   (setq y 3)
>   y ; -> 3
>   (foo) ; -> 1
>   (let ((x 4))
>     x ; -> 4?
>     (foo) ; -> 4
>     (setq x 5)
>     x ; -> 5
>     (foo) ; -> 5
>     ) ; end the let
>   y ; -> 3?
>   (foo) ; -> 4
>   )
> x ; -> 4
> (foo) ; -> 4

I haven't reviewed your compiler yet, and for that I apologize. But. You
need to make sure that when you compile, you build up a compile-time
environment, mapping symbols to locations -- if a variable is free,
lexically bound, or dynamically bound. When your compiler sees a lexical
binding, replace that identifier with a gensym, and add an entry to your
compile-time environment to map that identifier to that lexical gensym.
That way you will effectively be processing my example, which is
equivalent to yours, but perhaps clearer because the names have been
uniquified. Then your problems go away.

Peace,

Andy
-- 
http://wingolog.org/