On 2021-06-22 5:54 p.m., Chris Angelico wrote:
On Wed, Jun 23, 2021 at 6:41 AM Soni L. email@example.com wrote:
On 2021-06-22 5:23 p.m., Chris Angelico wrote:
On Wed, Jun 23, 2021 at 6:13 AM Soni L. firstname.lastname@example.org wrote:
Think about it like this, extension methods give you the ability to make imported functions that look like this:
look like this instead:
That's all there is to them. They're just a lie to change how you read/write the code. Some languages have an whole operator that has a similar function, where something like bar->foo(baz) is sugar for foo(bar, baz). The OP doesn't specify any particular mechanism for extension methods, so e.g. making the dot operator be implemented by a local function in the module, which delegates to the current attribute lookup mechanism by default, would be perfectly acceptable. It's like deprecating the existing dot operator and introducing a completely different one that has nothing to do with attribute lookup!
uh... I'm lost. Are you saying that that's a good thing? You *want* to replace the existing dot operator with one that has nothing to do with attribute lookup?? I don't get it.
Sure! As long as the new one can call getattr!
Let's say the new dot operator looks like this:
# file1.py def __dot__(left, right): print(left) print(right) ... foo =  foo.bar
Now, this would actually print the list  and the string "bar".
Then you can just use getattr to get attribute lookup behaviour out of it!
def __dot__(left, right): return getattr(left, right) foo =  foo.bar
It would have local scope, similar to uh... locals. Y'know how locals are just sugar for locals()['foo'] and stuff? Yeah.
Not really, no, they're not. :) The dictionary returned by locals() isn't actually an implementation detail of local name lookups.
It's... part of the language. Not an implementation detail. The dictionary returned by locals() is an inherent part of local name lookups, isn't it?
Have you put any thought into how you would deal with the problem of recursive __dot__ calls?
Let it recurse!
Globals and locals don't go through __dot__, so you can just... use them. In particular, you can always use getattr(), and probably should. Or even set __dot__ to getattr inside it, like so:
def __dot__(left, right): __dot__ = getattr foo.bar # same as getattr(foo, "bar") because we set (local) __dot__ to getattr above
In languages with lexical scoping (instead of block scoping), the compiler doesn't see things that haven't yet been declared. In those languages, such a __dot__ function would actually inherit the global __dot__ rather than recursing. But as you can see from the above example, it's really not a big deal.
ChrisA _______________________________________________ Python-ideas mailing list -- email@example.com To unsubscribe send an email to firstname.lastname@example.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://email@example.com/message/NEI23T... Code of Conduct: http://python.org/psf/codeofconduct/