Why dont languages allow overloading of methods by return value?

Question

c, java and many other languages do not pay attention to return values.

int   i = func()
float f = func()
int   func() { return 5 }
float func() { return 1.3}

Why isnt the above legal? Does it make it more difficult to program

int i = func(func(func(func2(func3())))) //you dont know what you are getting

Is it hard to write a compiler? are there more language unambiguity? Is there a language that can do the above?

Answer 1

Let's say it was allowed, which one would this call:

func();

That may not the the full answer, but I believe that is one reason why it is not legal.

Answer 2

What about this case?

class A implements Foo { /*...*/ }
class B implements Foo { /*...*/ }

A func() { return new A(); }
B func() { return new B(); }

Foo v = func(); // which do you call?!

There are already problems with ambiguity when you allow overloading of a single function name that take different arguments. Having to check the return type as well would probably make resolving the right function a lot harder.

I'm sure a language could implement that, but it would make things a lot more complicated, and would generally make the code harder to understand.

Answer 3

For a C++ example, consider:

void g(int x);
void g(float x);
g(func());

Which of the overloaded g() functions would be called?

Answer 4

Most languages allow for mixed-mode operations with automatic coercion (e.g. float + int), where multiple interpretations are legal. Without coercion, working with multiple numeric types (short, int, long, float, double) would become very cumbersome; with coercion, return-type based disambigation would lead to hard-to-understand code.

Answer 5

Allowing these may introduce problems. For example:

int i = func2(func());
int func() { return 5 }
float func() { return 1.3 }
int func(float a) { return a }
int func(int a) { return a }

This is ambiguous.

Answer 6

Perl allows a certain degree of return type variation, in that functions can tell what kind of context they're being evaluated in. For instance, a function that might return an array can see that it's running in a scalar context, and just return the putative length directly, sparing the allocation and initialization of the array just to get its length.