This email is broken up into multiple sections:
(1) Introduction
(2) Problem
(3) Probably Poor Solution
(4) Tangent (Utter Tomfoolery)
Introduction
Hello,
This is my first post to the list,
and I apologize for 4 reasons:
(1) I haven't been lurking for more than a few days.
(2) I am by no means well versed in python.
(3) I know nothing of language design.
(4) This isn't a very good introduction.
Nonetheless, I have a habit of beginning with institutions
that are on the verge of sweeping changes, and python
seems no different.
To curb the future troubles against which this unfortunate
fate of mine often forces me, I have been pouring over PEPs
(scanning really, because it's far past my bed time).
I came across the discussion of scoping, and while it seems
to be a very badly beaten and decaying horse, I ask that you'd
be kind enough to include me in this disgruntled discourse.
Problem
See http://www.python.org/dev/peps/pep-3104/
Consider the following:
>>> x = 10
>>> def a():
... x = 3
... def b():
... global x
... x = 4
... print x
...
... b()
... print x
...
>>> a()
4
3
>>> print x
4
The keyword 'global' is only good for the module scope.
Probably Poor Solution
See http://www.python.org/dev/peps/pep-3104/
There seems to be a predilection towards limited
and/or general means of outer scope referencing,
such as
(1) prefixing variables with dots.
(2) scope override declarations.
However, I don't understand the virtue of this generality
(of course, I haven't thought much about it either, so please
lend me your expertise).
Most of the time, it would seem a person should know exactly which
outer variable he is after; he knows exactly which scope.
Fortunately, the scopes in question are always named.
Can't we just reference what's already there?
>>> x = 10
>>> def a():
... x = 3
... def b():
... a.x = 4
... print a.x
...
... b()
... print x
...
>>> a()
4
4
>>> print x
10
Of course, the module itself is unnamed, and it would
be completely consistent to use the single prefixed dot
to reference it:
>>> x = 10
>>> def a():
... x = 3
... def b():
... a.x = 4
... print a.x
...
....x = 5
... b()
... print x
...
>>> a()
4
4
>>> print x
5
However, I would think a placeholder is easier to spot:
>>> x = 10
>>> def a():
... x = 3
... def b():
... a.x = 4
... print a.x
...
...@.x = 5
... b()
... print x
...
>>> a()
4
4
>>> print x
5
Of course, what happens if 'a' is a variable name?
>>> x = 10
>>> def a():
... x = 3
... def b():
... a = 15
... a.x = 4 #?
... print a.x
...
...@.x = 5
... b()
... print x
...
This would never happen in practice. Why bother considering it?
However, one could get around it with a fuller qualification:
>>> x = 10
>>> def a():
... x = 3
... def b():
... a = 15
... @.a.x = 4
... print a.x
...
...@.x = 5
... b()
... print x
...
>>> a()
4
4
>>> print x
5
In any case, those are just some thoughts off of the top of my
(tired) head.
It seems to me that it unifies a lot of scoping ideas. everything can
be accessed
with a qualified name.
Sorry if this is nonsensical.
Tangent (Utter Tomfoolery)
More interestingly, one sees (if one squints) the distinction between
modules,
classes, and functions blur:
>>> def new_b():
... print "tee hee"
>>> a.b = new_b()
>>>a()
tee hee
3
>>> print x
5
or perhaps:
>>> # Interestingly, the following code is valid already
...
>>> def Person(name, age, location):
... def print_record():
... print('The last person created had the name ' +
Person.name_last)
... print("However, I don't know any of the details")
...
... def instance():
... def print_record():
... print('Name: ' + name)
... print('age: ' + str(age))
... print('location: ' + location)
...
... if name == 'lingwitt':
... name = age = location = 'classified'
...
... Person.name_last = name
...
... return instance
...
>>>p1 = Person('spam', 80, 'eggsville')
>>>Person.name_last
spam
>>># Now the code becomes invalid
...
>>>Person.print_record()
The last person created had the name spam
However, I don't know any of the details
>>>p1.print_reco
