On Oct 17, 2019, at 05:08, Anders Hovmöller <bo...@killingar.net> wrote:
> 
> Well obviously never with literals. But most cases of multiplication aren't 
> with literals. So how can you get a type error when doing 
> 
> a*b
> 
> is the real question.  And the answer is now obvious: any time the programmer 
> thinks a and b are numbers but they are not.

If neither one is a number—in fact, if b is not an integer—you will get a 
TypeError.

Also, the reason you have no idea what’s in these variables is that you named 
them a and b instead of something meaningful. Normally if I have variables 
named a and b they’re going to be numbers (or maybe numpy arrays), because 
those are good names for two triangle side lengths but they’re very bad names 
for a list of strings and an integer Unix timestamp (to give an example which 
would allow * but it would be a logical error in your code that Python can’t 
catch).

At any rate, I definitely like using operators for concatenation and merging 
and elementwise array addition and so on. When I use other languages, I 
definitely run into annoyance with not having operator overloading in Java or 
JS much more often than I run into annoyance with abuse if operator overloading 
in C++ or Haskell. It’s not that it can’t happen, or even that it never happens 
in practice, it just happens a lot less often than getting lost trying to 
figure out what a simple array expression does because it had to be written in 
prefix form with long names and parens all over the place.

From a theoretical point of view, I’m sympathetic to the idea that they should 
all use _different_ operators from addition. But every time I go back to some 
Haskell code and have to look up the 48 different operators (all spelled as 
strings of punctuation characters) before I can understand what I wrote, and 
then I go back to some Python or C++ code and I already know that + means some 
kind of addition or concatenation no matter what the custom types are (and 
usually there’s only one kind that makes sense for the values), my theoretical 
sympathy is overridden by practical annoyance.

At any rate, the PEP is not proposing multiplication for repeated dict merge, 
and even the potential “add all the set operators” second PEP mentioned near 
the end is presumably not going to propose that, so I don’t think there’s much 
to gain by arguing about whether * for sequences was a mistake. If you want to 
propose adding a `repeat` method to the sequence types and deprecating or at 
least lightly discouraging the use of __mul__, that seems completely unrelated 
to this PEP.
_______________________________________________
Python-ideas mailing list -- python-ideas@python.org
To unsubscribe send an email to python-ideas-le...@python.org
https://mail.python.org/mailman3/lists/python-ideas.python.org/
Message archived at 
https://mail.python.org/archives/list/python-ideas@python.org/message/CO4GI52DJZAUQ6XDAY6FN3ZVK3KDXHXU/
Code of Conduct: http://python.org/psf/codeofconduct/

Reply via email to