On Thursday, 26 May 2016 at 06:23:17 UTC, Jonathan M Davis wrote:
The difference is that it's impossible to do
10.opBinary!"+"(15), so if you're forced to do
foo.opBinary!"+"(bar) to get around a symbol conflict, it won't
work with built-in types.
Obviously operator overloading should be limited to class and
struct types, so that's not really relevant.
UFCS does not have that problem, because you're dealing with
free functions and can choose to not use UFCS and provide the
full import path or to alias the function, which you can't do
with operators - particularly built-in operators.
I still don't understand what you're getting at, unfortunately.
D was designed to be much cleaner with operator overloading
than C++ is. It restricts what the definitions of the operators
are so that you don't have to define as many of them to get the
basic operations (e.g. opCmp for most of the comparison
operators or op!"++" for both pre-increment and post-increment)
and so that they aren't easily overloaded to do stuff that does
not correspond to what that operator does for built-in types. D
doesn't even use + for string concatenation, because Walter
thought that that was operator abuse. Allowing arbitrary code
to add overloaded operators to an existing type is not at all
in line with that philosophy.
Regardless, there really isn't much point in arguing this. If
you want things to change, you're going to need to convince
Walter, which I very much doubt is going to happen.
- Jonathan M Davis
Thanks for taking the time to explain, although I still fail to
see a good justification for disabling UFCS for operators. I will
look for more discussions on the topic and if still no opposing
argument seems valid I might push the issue forward.
