On Mon, Sep 8, 2014 at 10:30 PM, Stephen R. van den Berg srb@cuci.nl wrote:
Let the record show though that I consider it to be a rather messy way to handle this :-).
I've worked with Python's way of doing things, and it has its own issues. This kind of thing comes up periodically on python-list:
t = ("Foo", [1,2], "Bar") t[1] += [3]
Traceback (most recent call last): File "<pyshell#2>", line 1, in <module> t[1] += [3] TypeError: 'tuple' object does not support item assignment
t
('Foo', [1, 2, 3], 'Bar')
In Python, "x += y" becomes "x = x.__iadd__(y)", which means two things:
1) The object is asked to do an in-place addition with the new contents 2) Whatever is returned is stored back where x was.
The tuple rejects the second half of that (tuples are immutable, so you can't assign to their members), but the first half has already happened, and this causes some confusion.
With Pike's semantics, "t[1] += whatever" becomes "t[1] = t[1] + whatever", which won't change t[1] at all if the assignment fails. There's a much stronger incentive to write explicit methods to do the appending (in Python's case, lists have a .extend() method that's better suited to this, but there's a temptation to use += anyway), because it's guaranteed to be more efficient.
Personally, I think use of += for anything other than pure optimization is a dangerous idea - the expected semantics aren't as obvious as you might think. It's easy with immutables like strings and integers (this is true in both Python and Pike, btw), but for mutables, it's cleaner to work with methods.
ChrisA