On Monday, 12 November 2018 at 22:07:39 UTC, Walter Bright wrote:
On 11/12/2018 12:34 PM, Neia Neutuladh wrote:
Tell me more about this "consistency".
int f(short s) { return 1; }
int f(int i) { return 2; }
enum : int { a = 0 }
enum A : int { a = 0 }
pragma (msg, f(a)); // calls f(int)
pragma (msg, f(A.a)); // calls f(short)
I.e. it's consistent.
Here's how it works:
f(a): `a` is a manifest constant of type `int`, and `int` is an
exact match for f(int), and f(short) requires an implicit
conversion. The exact match of f(int) is better.
f(A.a): `a` is an enum of type `A`. `A` gets implicitly
converted to `int`. The `int` then gets exact match to f(int),
and an implicit match to f(short). The sequence of conversions
is folded into one according to:
<implicit conversion> <exact> => <implicit
conversion>
<implicit conversion> <implicit conversion> => <implicit
conversion>
Doesn't the above miss a step, and wouldn't it be:
1) A.a => <implicit-convert-to-int><exact-match-on-f(int)>
2) A.a =>
<implicit-convert-to-int><implicit-convert-to-short><exact-match-on-f(short)>
So basically for the f(short) path you have 3 steps instead of 2
for the f(int) path.
So does it matter how many implicit conversions need to happen
before D stops trying? Or is it basically convert as long as you
can? Does D actually do a "find the shortest path via implicit
conversions to an overload" algorithm?
One could have <implicit conversion><exact> be treated as
"better than" <implicit conversion><implicit conversion>, and
it sounds like a good idea, but even C++, not known for
simplicity, tried that and had to abandon it as nobody could
figure it out once the code examples got beyond trivial
examples.
Interesting. This seems simpler intuitively (shorter path, pick
it), so I'm wondering if there're any links you can point to that
describe what these problems were?
Cheers,
- Ali
