[Python-Dev] Re: closure semantics

[Skip Montanaro]

    >> That would be solved if, instead of marking variables in inner scopes
    >> that refer to outer scopes, it were the other way round, and
    >> variables in the outer scope were marked as being rebindable in inner
    >> scopes.
    ...
    Guido> This would only apply to *assignment* from inner scopes, not to
    Guido> *use* from inner scopes, right?  (Otherwise it would be seriously
    Guido> backwards incompatible.)

Given that the global keyword or something like it is here to stay (being
preferable over some attribute-style access) and that global variable writes
needs to be known to the compiler for future efficiency reasons, I think we
need to consider modifications of the current global statement.  The best
thing I've seen so far (I forget who proposed it) is

    'global' vars [ 'in' named_scope ]

where named_scope can only be the name of a function which encloses the
function containing the declaration.  In Greg's example of inc_x_by nested
inside f, he'd have declared:

    global x in f

in inc_x_by.  The current global statement (without a scoping clause) would
continue to refer to the outermost scope of the module.

This should be compatible with existing usage.  The only problem I see is
whether the named_scope needs to be known at compile time or if it can be
deferred until run time.  For example, should this

    import random
    def outer(a):
        x = a
        def inner(a):
            x = 42
            def innermost(r):
                if r < 0.5:
                    global x in inner
                else:
                    global x in outer
                x = r
            print "  inner, x @ start:", x
            innermost(random.random())
            print "  inner, x @ end:", x
        print "outer, x @ start:", x
        inner(a)
        print "outer, x @ end:", x
    outer(12.73)

be valid?  My thought is that it shouldn't.

Skip