[Python-Dev] LOAD_NAME & classes

[Tim Peters]

[Greg Ewing]
> I doubt whether the early designers of Lisp explicitly designed
> it to have dynamic scoping. Coming from lambda calculus, they
> were probably *thinking* of lexical scoping; it's just that
> the implementation they chose had some unfortunate side effects.

I think McCarthy may be a good source <wink>:

    http://www-formal.stanford.edu/jmc/history/lisp/lisp.html

The distinction between dynamic and lexical scoping is clear-cut only in
hindsight.  As McCarthy relates, Algol 60 later bumped into much the same
scoping surprises they did.

The treatment of free variables in formal logic is also much clearer in
hindsight, and was the source of many difficulties before a proper
definition of substitution was crafted.  Cute:  Curry and Schoenfinkel
(independently) invented combinatory logic to get rid of free variables (and
the difficulties that come with them) entirely, and decades later
combinatory logic overthrew the lambda calculus as the basis for
high-performance implementations of pure functional languages.

Applying a contemporary understanding of these things retroactively just
doesn't fly; whatever clarity we have now was a result of their struggles.

> ...
> By the way, even in dynamically scoped Lisp, there's no
> equivalent of an UnboundLocalError -- to get a local variable
> at all, you have to bind some initial value to it.

There were certainly NameErrors.  All you needed to do was evaluate any old
function that referenced a free variable, at a time when no binding for that
variable was on the stack.  You can't do this in Scheme, but it was dead
easy in LISP; it's harder in Common Lisp, but dynamic scoping can still be
gotten at there.

> So, using Guido's terminology, early Lisp had dynamic scoping, but
> not dynamic lookup. Confused enough yet?-)

Not as confused as McCarthy turned out to have been <wink>.