On Tue, 12 Aug 2014 13:17:37 +0000 Meta via Digitalmars-d-learn <digitalmars-d-learn@puremagic.com> wrote:
> On Tuesday, 12 August 2014 at 06:37:45 UTC, Jonathan M Davis via > Digitalmars-d-learn wrote: > > The problem is that isNaN is now templatized, and its > > constraint uses > > isFloatingPoint, which requires that the type _be_ a floating > > point type, not > > that it implicitly convert to one. So, as it stands, isNAN > > cannot work with > > any type which implicitly converts to a floating point value. > > Either it will > > have to be instantiated with the floating point type - e.g. > > isNaN!float(s) - > > or you're going to have to explicitly cast s to a floating > > point type. > > > > You can open a bug report - https://issues.dlang.org - and mark > > it as a > > regression, and it might get changed, but the reality of the > > matter is that > > templates don't tend to play well with implicit conversions. > > It's _far_ too > > easy to allow something in due to an implicit conversion and > > then have it not > > actually work, because the value is never actually converted. > > In general, I > > would strongly advise against attempting to give types implicit > > conversions > > precisely because they tend to not play nicely with templates. > > > > - Jonathan M Davis > > I think this should be considered a bug. A type with alias this > should work in all cases that the aliased type would. If the > function fails to be instantiated with S!float, then it should be > forwarded to the S's val member. AFAIK, the only time that the implicit conversion would take place is when the type is being used in a situation where it doesn't work directly but where the aliased type is used. In that case, the compiler sees the accepted types and sees that the type can implicitly convert to one of the accepted types and thus does the conversion. So, it knows that the conversion will work before it even does it. The compiler never attempts to do the conversion just to see whether it will work, which is essentially what it would have to do when attempting to use the type with a templated function. You can certainly create an enhancement request for such behavior, but I have no idea how likely it is get implemented. There are currently _no_ cases where the compiler does anything with template instantiations to try and make them pass if simply trying to instantiate them with the given type failed. - Jonathan M Davis