On Thu, 27 Jun 2013 20:34:53 -0400, JS <[email protected]> wrote:
Would it be possible for a language(specifically d) to have the ability
to automatically type a variable by looking at its use cases without
adding too much complexity? It seems to me that most compilers already
can infer type mismatchs which would allow them to handle stuff like:
main()
{
auto x;
auto y;
x = 3; // x is an int, same as auto x = 3;
y = f(); // y is the same type as what f() returns
x = 3.9; // x is really a float, no mismatch with previous type(int)
}
in this case x and y's type is inferred from future use. The compiler
essentially just lazily infers the variable type. Obviously ambiguity
will generate an error.
There are very good reasons not to do this, even if possible. Especially
if the type can change.
Consider this case:
void foo(int);
void foo(double);
void main()
{
auto x;
x = 5;
foo(x);
....
// way later down in main
x = 6.0;
}
What version of foo should be called? By your logic, it should be the
double version, but looking at the code, I can't reason about it. I have
to read the whole function, and look at every usage of x. auto then
becomes a liability, and not a benefit.
Coupling the type of a variable with sparse usages is going to be
extremely confusing and problematic. You are better off declaring the
variable as a variant.
-Steve
