Non-consistent implicit function template specializations
Rekel
paultjeadriaanse at gmail.com
Wed Aug 18 11:06:58 UTC 2021
On Tuesday, 17 August 2021 at 18:27:21 UTC, Steven Schveighoffer
wrote:
> According to my tests, it prefers the `T` version over the
> static array version. Which leads me to believe that it prefers
> a dynamic array over a static one. In fact, if I comment out
> the `T` version, it doesn't compile. It literally will not pick
> that specialization, even if it can interpret the literal that
> way.
>
> which is really bizarre, since if you do it without
> specializations, but just spelling out all the template
> components (as in your alternative workaround), it WILL pick
> that one over a dynamic array one.
Oh my, that's weird... Not meant to bash but given all I've seen
of argument deduction & templates & specializations... I think
the implementation needs some serious rework 😅
---
Interestingly enough my approach will not even work for 2d array
literals. It will manage going to int[][2], but int[2][2] is one
step too far. Which is a real bummer. :(
That is, it won't figure it out itself, but when you call `foo(T,
uintL)(T[L][L]...` using an explicit `foo!(int, 2)` it _will_
work. Even though it manages T[L] just fine.
Meanwhile T[2][L] _and_ T[L][2] won't work when called with a 2x2
array literal.
More information about the Digitalmars-d-learn
mailing list