Re: Recursive environments (closures-related)

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

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