Re: Recursive environments (closures-related)

Max Hailperin <>
20 Jan 2007 23:31:18 -0500

          From comp.compilers

Related articles
Recursive environments (closures-related) (Pupeno) (2007-01-17)
Re: Recursive environments (closures-related) (Russ Cox) (2007-01-17)
Re: Recursive environments (closures-related) (Max Hailperin) (2007-01-18)
Re: Recursive environments (closures-related) (George Neuner) (2007-01-18)
Re: Recursive environments (closures-related) (George Neuner) (2007-01-18)
Re: Recursive environments (closures-related) (Max Hailperin) (2007-01-20)
| List of all articles for this month |

From: Max Hailperin <>
Newsgroups: comp.compilers,comp.lang.scheme
Followup-To: comp.lang.scheme
Date: 20 Jan 2007 23:31:18 -0500
Organization: Compilers Central
References: 07-01-050 07-01-057 07-01-061
Keywords: Lisp
Posted-Date: 20 Jan 2007 23:31:18 EST

George seems to have misunderstood the original poster in at least
three ways:

  (1) He seems to have missed that the keyword "let*" is being used by
          the original poster in a nonstandard way, for what would normally
          be called letrec, with no connection to the standard let*.

  (2) He seems to have missed the original poster's explanation of his
          approach (mutating a closure to refer to a different environment
          than it originally did), and so is reduced to speculating about
          mechanisms ("Given the OP claim that recursive calls work
          properly, one of two things must be true."). No speculation is
          needed. The original poster showed a mechanism that would make
          simple cases of recursion work--though not, as I pointed out,
          more complicated ones.

  (3) He seems to confuse "runtime lookup" with "dynamic scoping." At
          least, that is the only way I can make sense out of the comment
          that "or all names are resolved by runtime lookup in which case
          the extended environment containing the procedure name would
          already be in place." The original poster provided enough
          context that we can be sure his interpreter *was* using runtime
          lookup of all names, but also equally sure that it was using
          lexical scoping rather than dynamic scoping.

I would respectfully suggest that this thread, if it is to continue,
would be better moved over to comp.lang.scheme, where there is a
higher density of people with the relevant expertise. -max

Post a followup to this message

Return to the comp.compilers page.
Search the comp.compilers archives again.