function overload on full signature?

[Rob T]

I've been wondering for a couple of years about why overloading 
stops at the argument sig in almost all languages, but so far I 
have not seen a good reason why this must be so.

 From what I've read so far, the reason why full overloading is 
not being done, is because it is not being done. Other than that, 
I don't have an answer as to why it is not being done because 
clearly it can be done, and the compiler certainly has the means 
to do it already, otherwise it could not err when you assign a 
function return type to the wrong type on the LHS, ie, it most 
certainly is able to determine what the full signature is at some 
point.

So does anyone really know why it is not being done? The "it's 
too complicated" argument seems weak to me since the compiler 
already has to check for both matching argument sig as well as 
the return type, and it already does overloading on the argument 
sig. I figure "it's too complicated" only because the compiler 
was initially designed without taking full signature overloading 
into account from the very start, otherwise it would be not much 
more complicated than the regular overloading that we have now.

The argument that the compiler will get too confused seems a bit 
weak as well, since the compiler can already get confused with 
argument sig overloading, and there are certainly methods of 
working this out, otherwise function overloading would not work 
as it is now. At the end of the day, if the compiler cannot 
figure it out, then it errs, just as it does now when it cannot 
figure it out. There's already an incalculable number of ways a 
programmer can mess up a valid compile, so adding one more 
possible way to the already massive pile cannot be used as a 
reason why it should not be done.

I could argue that overloading only on function sig is too 
complicated and not worth it, but we have it, and it is useful to 
at least some or most people, so why did we stop at the argument 
sig and not go all the way? Is there a theoretical reason why we 
should stop, are their use cases that have shown that it fails to 
help the programmer or makes programming more difficult?

--rt