[Python-ideas] Augmented assignment syntax for objects.

[Erik]

On 28/04/17 10:47, Paul Moore wrote:
> On 28 April 2017 at 00:18, Erik <python at lucidity.plus.com> wrote:
>>> The semantics are very different and there's little or no connection
>>> between importing a module and setting an attribute on self.
>>
>> At the technical level of what goes on under the covers, yes. At the higher
>> level of what the words mean in spoken English, it's really not so different
>> a concept.
>
> I disagree. If you were importing into the *class* (instance?) I might
> begin to see a connection, but importing into self?

I know you already understand the following, but I'll spell it out 
anyway. Here's a module:

-----------------
$ cat foo.py
def foo():
   global sys
   import sys

   current_namespace = set(globals().keys())
   print(initial_namespace ^ current_namespace)

def bar():
   before_import = set(locals().keys())
   import os
   after_import = set(locals().keys())
   print(before_import ^ after_import)

initial_namespace = set(globals().keys())
-----------------

Now, what happens when I run those functions:

$ python3
Python 3.5.2 (default, Nov 17 2016, 17:05:23)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
 >>> import foo
 >>> foo.foo()
{'sys', 'initial_namespace'}
 >>> foo.bar()
{'before_import', 'os'}
 >>>

... so the net effect of "import" is to bind an object into a namespace 
(a dict somewhere). In the case of 'foo()' it's binding the module 
object for "sys" into the dict of the module object that represents 
'foo.py'. In the case of 'bar()' it's binding the module object for "os" 
into the dict representing the local namespace of the current instance 
of the bar() call.

Isn't binding an object to a namespace the same operation that 
assignment performs?

So it's a type of assignment, and one that doesn't require the name to 
be spelled twice in the current syntax (and that's partly why I took 
offense at a suggestion - not by you - that I was picking "random or 
arbitrary" keywords. I picked it for that specific reason).

I realize that there are other semantic changes (importing a module 
twice doesn't do anything - and specifically repeated "import * from 
mod" will not do anything if the module mutates) - and perhaps this is 
your point.

> Also, if you try to make the obvious generalisations (which you'd *have* to be able to
> make due to the way Python works) things quickly get out of hand:
>
> def __init__(self, a):
>     self import a

self.a = a

>
> OK, but self is just a variable name, so we can reasonably use a different name:
>
> def __init__(foo, a):
>     foo import a

foo.a = a

> So the syntax is <variable> import <var-list>
>
> Presumably the following also works, because there's nothing special
> about parameters?
>
> def __init__(x, a):
>     calc = a**2
>     x import calc

x.calc = calc

> And of course there's nothing special about __init__
>
> def my_method(self, a):
>     self import a

self.a = a

> Or indeed about methods
>
> def standalone(a, b):
>     a import b

a.b = b

> or statements inside functions:
>
> if __name __ == '__main__:
>     a = 12
>     b = 13
>     a import b

a.b = b

> Hmm, I'd hope for a type error here. But what types would be allowed
> for a?

I think you're assuming I'm suggesting some sort of magic around "self" 
or some such thing. I'm not. I've written above exactly what I would 
expect the examples to be equivalent to. It's just an assignment which 
doesn't repeat the name (and in the comma-separated version allows 
several names to be assigned using compact syntax without spelling them 
twice, which is where this whole thing spawned from).

> See what I mean? Things get out of hand *very* fast.

I don't see how that's getting "out of hand". The proposal is nothing 
more complicated than a slightly-different spelling of assignment. It 
could be done today with a text-based preprocessor which converts the 
proposed form to an existing valid syntax. Therefore, if it's "out of 
hand" then so is the existing assignment syntax ;)

FWIW, I should probably state for the record that I'm not actually 
pushing for _anything_ right now. I'm replying to questions asked and 
also to statements made which I think have missed the point of what I 
was trying to say earlier. So I'm just engaging in the conversation at 
this point - if it appears confrontational then it's not meant to.

> To summarise:
>
> 1. There's some serious technical issues with your proposal, which as
> far as I can see can only be solved by arbitrary restrictions on how
> it can be used

To be honest, I still don't understand what the serious technical issues 
are (other than the parser probably doesn't handle this sort of 
keyword/operator hybrid!). Is it just that I'm seeing the word "import" 
in this context as a type of assignment and you're seeing any reference 
to the word "import" as being a completely different type of operation 
that comes with baggage?

Regards, E.