Re: Real-life examples of lexical binding in Emacs Lisp

[Rusi]

On Saturday, May 30, 2015 at 9:20:19 PM UTC+5:30, Pascal J. Bourguignon wrote:
> Rusi  writes:
> 
> > On Saturday, May 30, 2015 at 6:20:13 PM UTC+5:30, Pascal J. Bourguignon 
> > wrote:
> >> Rusi  writes:
> >> 
> >> > I'd say you are getting this from the wrong end.
> >> > Today (2015) dynamic scoping is considered a bug
> >> 
> >> "Bug" is too strong a word here.
> >> 
> >> 
> >> > In 1960 when Lisp was invented of course people did not realize this.
> >> > This is just a belated bug-fix
> >> 
> >> It is actually in 1960 (or a few years after) when LISP was invented,
> >> that people realized there was the so called "Funarg problem".  During
> >> the 60s this problem has been studied, several (faulty) solutions
> >> proposed, and eventually the notions of lexical binding vs. dynamic
> >> binding and environments were elaborated.
> >
> > I dont understand why the funarg problem is at issue here.
> >
> > If foo calls bar (not nested within foo)
> > And bar references x which it does not define
> > The natural expection is a 'Variable undefined' error.
> > However in a dynamic scoping discipline, you will get the error if
> > foo does NOT define x; else bar will get foo's private x.
> > I dont see how this can be regarded as not buggy -- no need to bring in
> > functional/higher-order aspects at all.
> 
> It's not buggy, because it's the behavior of this tools.
> 
> You cannot complain that chainsaw section arms and legs: this is the
> behavior of chainsaws.  Just learn how to use them for good use: section
> only trees or zombies.
> 
> 
> The funarg problem shows that what was wanted with the introduction of
> lambda was not dynamic binding, but lexical binding, so that closures
> could be created by lambda.

Heh!
If scope leaks in straightforward first-order code you say its 
what-you-ask-that-you-get -- chainsaw.
If scope leaks (downward funarg) or breaks (upward funarg) you say the scoping
is at fault.
You're having it both ways aint you Pascal?!

> 
> 
> >> Other languages such as Fortran and Algol had already something like
> >> lexical binding, but it was actually as accidental as the dynamic
> >> binding of LISP, and of no consequence, since in those languages it was
> >> not possible to create closures anyways. 
> >
> > There is somebody-or-other's law (sorry cant remember the reference) to the 
> > effect:
> > When a language is designed from ground up it usually gets scoping right.
> > When a language slowly evolves out of mere configuration into more and more
> > features into full Turing-completeness, it invariably gets scoping wrong.
> > Examples (in addition to Lisp): perl, python, lua and most famously 
> > javascript
> >
> > I conclude:
> > a. Scoping is a much harder problem than appears at first blush
> > b. Compiled languages tend to get it more right than interpreted
> 
> When LISP was designed, the notion of scoping was just not considered.

This much we can agree

> It's the invention of LISP and the detection of the funarg problem that
> made people think about it, and eventually invent lexical binding and
> environments.

Please see the Algol report www.masswerk.at/algol60/report.htm
The notion of block is fundamental there
In fact the scheme report RnRS used to to trace scheme's lineage as much to
Algol as to Lisp. The Algol contribution was block structure.