On Wednesday, 14 November 2012 at 02:01:56 UTC, Jonathan M Davis
wrote:
It would also screw up covariant return types if overloading
too the return
type into account. I believe that the _big_ reason though is
simply because
the type of the expression is determined by the return type,
not what it's
assigned to. For instance, with how the language works, the
type of the right-
hand side of an assignment must always be determined
independently of the type
on the left, so the type of the expression on the right-hand
side cannot
depend on the type of the left. I suspect that it would
complicate things
considerably to try and make the return type have anything to
do with function
overloading. I'm sure that you could find it being discussions
on it somewhere
online for other C-based laguages though.
Regardless, I've never even heard of a language which tried to
include the
return type in overload resolution. It sounds like a huge
complication to me.
- Jonathan M Davis
I can envision simple ways for a programmer to supply hints to
the compiler for easy resolution based on return type.
For example, when calling an overloaded function without
assignment to anything:
int f() { ... }
void f() { ... }
f(); // should choose void return
(void)f(); // calls void return
(int)f(); // calls int return
In C++ there are conversion operators, which are not exactly the
same as function overloading, but the correct function is
selected based on the type on the left hand side.
Example
class A
{
operator bool(){ return _b; }
operator int(){ return _i; }
int _i; bool _b;
}
A a;
bool b = a; // executes bool()
int i = a; // executes int()
Is there anything like C++ conversion operators in D? I have used
conversion ops in C++ and may want to use a similar feature in D
if available.
--rt
