On Friday, 14 February 2025 at 04:28:25 UTC, Dom DiSc wrote:
Why does this happen:
```d
void foo(long x) { }
void foo(ulong x) { }
main()
{
foo(short(17)); // error: `foo` called with argument types
`(short)` matches both: `foo(long x)` and: foo(ulong x)`
}
```
Why does a short match an unsigned type with same priority as a
signed type?!?
Clearly a longer type with matching signedness should always be
a better match than a type that will discard the sign, no?
Here's the spec for overload resolution:
https://dlang.org/spec/function.html#function-overloading
In your example, both overloads have match level 2: "match with
implicit conversions". So the compiler attempts to figure out
which one is more specialized by checking whether the parameters
of one overload can be used to call the other overload.
* `long x` can be used to call `foo(ulong)`, so `foo(long)` is at
least as specialized as `foo(ulong)`.
* `ulong x` can be used to call `foo(long)`, so `foo(ulong)` is
at least as specialized as `foo(long)`.
Oops--it turns out both overloads are equally specialized! So you
get an ambiguity error.
