On 7/3/06, Andrew Koenig <ark@acm.org> wrote:
Much though the Algol 60 tickles my nostalgia (it was my first programming language!) I don't think that it's a particularly strong argument. I like to think that we have better ways these days.
Even if so, that's not the point I was trying to make. The point is that there is a programming technique that is widely used, works in many languages, and has been around for 45 years; and when you try to use it in Python, it fails.
That's true for lots of things that have been around for a long time. Can you provide a better example? (The use of += is not particularly relevant to the example; it could just as well have said "result = result + i".)
I believe that such failures, even if there are alternative ways of solving the problems that engender them, are barriers to learning that should be removed if it is possible to do so without substantial cost.
And that is of course the crucial question. Probably the only proposal that has any chance of succeeding is to extend the 'global' statement so that it also applies to variables in intermediate outer scopes; or perhaps a new keyword (since "global" is not a very good name for the extended semantics). We would have to decide what this example would do: def outer(): def inner1(x): global a a = x def inner2(): return a return inner1, inner2 f1, f2 = outer() g1, g2 = outer() f1(42) g1(0) print f2() # Does it print 0 or 42 ??? In current Python this prints 0: there's only one (global) variable a, and the call to g1(0) overrides the value that was stored by f1(42). If global were changed to mean "nonlocal" what should it do? The question the example poses is that a is not initialized except in inner1() -- we somehow have to decide whether this is an error, or whether it chooses some well-defined outer scope, with the choices being the nearest enclosing scope or the outermost (truly global) scope. We have one guideline: if there is exactly one outer scope that defines a variable named a, we would like it to be referenced (by the 'global a') statement and the variable references governed by it automatically. Also, of there's more than one such scope, we'd like it to reference the innermost one. But this doesn't have a natural extension to what should happen if there's no such scope! Perhaps the best solution would be to make it an error if there wasn't a visible variable named a in an outer scope. That would suit me fine because I'd like to migrate towards more static analysis of variables anyway. If that means equipping modues with traps for attempts to store arbitrary variables into their namespaces, that's fine with me (as long as there's some escape -- and of course instancs and classes remain fully dynamic). -- --Guido van Rossum (home page: http://www.python.org/~guido/)