On 2011-02-07, at 20:43 , Manuel Bärenz wrote:

In C++, the the approach to the namespace problem is having different namespaces that should not contain different definitions of the same name. Members of a namespace can be accessed explicitly by e.g. calling "std::cout<< etc." or "using namespace std; cout<< etc."

I understand Pythons approach to be "objects can be used as namespaces and their attributes are the names they contain". I find this a very beautiful way of solving the issue, but it has a downside, in my opinion, because it lacks the "using" directive from C++.

If the object is a module, we can of course do "from mymodule import spam, eggs". Or `from mymodule import *` though that's not exactly recommended.

On the other hand, since when can `using` be used on anything but a C++ namespace (which as far as I know is a well-defined entity, not an arbitrary object, and quite similar to a Python module though not identical)?

But if it is not a module, this does not work.

Consider for example:

class Spam(object): def frobnicate(self): self.eggs = self.buy_eggs() self.scrambled = self.scramble(self.eggs) return self.scrambled> 42

This could be easier to implement and read if we had something like:

class Spam(object): def frobnicate(self): using self: eggs = buy_eggs() scrambled = scramble(eggs) return scrambled> 42

Of course this opens a lot of conceptual questions like how should this using block behave if self doesn't have an attribute called "eggs", but I think it is worth considering.

My 2 cents: Javascript has this "feature" (with). It's utterly terrible, and mainly a very good way to shoot yourself in the foot repeatedly. I especially find the assertion that:

This could be easier to […] read

Extremely debatable: in my experience of that feature in Javascript, it makes code much harder to understand and reason about.

Manuel Bärenz wrote: [...]

This could be easier to implement and read if we had something like:

class Spam(object): def frobnicate(self): using self: eggs = buy_eggs() scrambled = scramble(eggs) return scrambled> 42

Of course this opens a lot of conceptual questions like how should this using block behave if self doesn't have an attribute called "eggs", but I think it is worth considering.

In Foxpro, the keyword is 'with' instead of 'using', and to make it clear when the to look into the namespace for the variable (instead of, for example, locals), the variable name is prepended with a '.'; so the example above becomes: class Spam(object): def frobnicate(self): with self: .eggs = buy_eggs() .scrambled = scramble(eggs) return .scrambled > 42 While I have occasionally missed this feature, I haven't lost any sleep over it, either. -1 without leading periods +0 with leading periods no preference on keyword name (with vs using vs ...) ~Ethan~

Manuel Bärenz wrote:

In C++, the the approach to the namespace problem is having different namespaces that should not contain different definitions of the same name. Members of a namespace can be accessed explicitly by e.g. calling "std::cout<< etc." or "using namespace std; cout<< etc."

This is like the "with" statement of Pascal, and is already a Python FAQ: http://docs.python.org/faq/design.html#why-doesn-t-python-have-a-with-statem... -- Steven

On 2011-02-07, at 20:43 , Manuel Bärenz wrote:

In C++, the the approach to the namespace problem is having different namespaces that should not contain different definitions of the same name. Members of a namespace can be accessed explicitly by e.g. calling "std::cout<< etc." or "using namespace std; cout<< etc."

I understand Pythons approach to be "objects can be used as namespaces and their attributes are the names they contain". I find this a very beautiful way of solving the issue, but it has a downside, in my opinion, because it lacks the "using" directive from C++.

If the object is a module, we can of course do "from mymodule import spam, eggs". Or `from mymodule import *` though that's not exactly recommended.

On the other hand, since when can `using` be used on anything but a C++ namespace (which as far as I know is a well-defined entity, not an arbitrary object, and quite similar to a Python module though not identical)?

But if it is not a module, this does not work.

Consider for example:

class Spam(object): def frobnicate(self): self.eggs = self.buy_eggs() self.scrambled = self.scramble(self.eggs) return self.scrambled> 42

This could be easier to implement and read if we had something like:

class Spam(object): def frobnicate(self): using self: eggs = buy_eggs() scrambled = scramble(eggs) return scrambled> 42

Of course this opens a lot of conceptual questions like how should this using block behave if self doesn't have an attribute called "eggs", but I think it is worth considering.

My 2 cents: Javascript has this "feature" (with). It's utterly terrible, and mainly a very good way to shoot yourself in the foot repeatedly. I especially find the assertion that:

This could be easier to […] read

Extremely debatable: in my experience of that feature in Javascript, it makes code much harder to understand and reason about.

Manuel Bärenz wrote: [...]

This could be easier to implement and read if we had something like:

class Spam(object): def frobnicate(self): using self: eggs = buy_eggs() scrambled = scramble(eggs) return scrambled> 42

Of course this opens a lot of conceptual questions like how should this using block behave if self doesn't have an attribute called "eggs", but I think it is worth considering.

In Foxpro, the keyword is 'with' instead of 'using', and to make it clear when the to look into the namespace for the variable (instead of, for example, locals), the variable name is prepended with a '.'; so the example above becomes: class Spam(object): def frobnicate(self): with self: .eggs = buy_eggs() .scrambled = scramble(eggs) return .scrambled > 42 While I have occasionally missed this feature, I haven't lost any sleep over it, either. -1 without leading periods +0 with leading periods no preference on keyword name (with vs using vs ...) ~Ethan~

Manuel Bärenz wrote:

In C++, the the approach to the namespace problem is having different namespaces that should not contain different definitions of the same name. Members of a namespace can be accessed explicitly by e.g. calling "std::cout<< etc." or "using namespace std; cout<< etc."

This is like the "with" statement of Pascal, and is already a Python FAQ: http://docs.python.org/faq/design.html#why-doesn-t-python-have-a-with-statem... -- Steven