On Thu, Sep 6, 2018 at 2:23 PM Chris Angelico <ros...@gmail.com> wrote:
>
> On Fri, Sep 7, 2018 at 4:11 AM, Franklin? Lee
> <leewangzhong+pyt...@gmail.com> wrote:
> > On Tue, Aug 28, 2018 at 6:37 PM Greg Ewing <greg.ew...@canterbury.ac.nz>
> > wrote:
> >>
> >> Guido van Rossum wrote:
> >> > we might propose (as the OP did) that this:
> >> >
> >> > a, b, c += x, y, z
> >> >
> >> > could be made equivalent to this:
> >> >
> >> > a += x
> >> > b += y
> >> > c += z
> >>
> >> But not without violating the principle that
> >>
> >> lhs += rhs
> >>
> >> is equivalent to
> >>
> >> lhs = lhs.__iadd__(lhs)
> >
> > (Corrected: lhs = lhs.__iadd__(rhs))
> >
> > Since lhs here is neither a list nor a tuple, how is it violated? Or
> > rather, how is it any more of a special case than in this syntax:
> >
> > # Neither name-binding or setitem/setattr.
> > [a,b,c] = items
> >
> > If lhs is a Numpy array, then:
> > a_b_c += x, y, z
> > is equivalent to:
> > a_b_c = a_b_c.__iadd__((x,y,z))
> >
> > We can translate the original example:
> > a, b, c += x, y, z
> > to:
> > a, b, c = target_list(a,b,c).__iadd__((x,y,z))
> > where `target_list` is a virtual (not as in "virtual function") type
> > for target list constructs.
>
> What is the virtual type here, and what does its __iadd__ method do? I
> don't understand you here. Can you go into detail? Suppose I'm the
> author of the class that all six of these objects are instances of;
> can I customize the effect of __iadd__ here in some way, and if so,
> how?
I shouldn't have used jargon I had to look up myself.
The following are equivalent and compile down to the same code:
a, b, c = lst
[a, b, c] = lst
The left hand side is not an actual list (even though it looks like
one). The brackets are optional. The docs call the left hand side a
target list:
https://docs.python.org/3/reference/simple_stmts.html#assignment-statements
"Target list" is not a real type. You can't construct such an object,
or hold one in memory. You can't make a class that emulates it
(without interpreter-specific hacks), because it is a collection of
its names, not a collection of values.
target_list.__iadd__ also does not exist, because target_list does not
exist. However, target_list can be thought of as a virtual type, a
type that the compiler compiles away. We can then consider
target_list.__iadd__ as a virtual operator, which the compiler will
understand but hide from the runtime.
I was making the point that, because the __iadd__ in the example does
not refer to list.__iadd__, but rather a virtual target_list.__iadd__,
there is not yet a violation of the rule.
_______________________________________________
Python-ideas mailing list
Python-ideas@python.org
https://mail.python.org/mailman/listinfo/python-ideas
Code of Conduct: http://python.org/psf/codeofconduct/
