On Tuesday, 12 August 2014 at 06:37:45 UTC, Jonathan M Davis via Digitalmars-d-learn wrote:
On Tue, 12 Aug 2014 06:21:17 +0000
uri via Digitalmars-d-learn <digitalmars-d-learn@puremagic.com> wrote:

Hi,

I'm trying to allow implicit conversions for my own type
happening. I have the following:

----
import std.math;
import std.traits;

struct S(T)
if(isFloatingPoint!T)
{
     T val;
     alias val this;
}
void main()
{

     auto s = S!float();
     assert(isNaN(s));
     s = 10.0;
     assert(!isNaN(s));
}
----

But I get a compile time error:

----
Error: template std.math.isNaN cannot deduce function from
argument types !()(S!float), candidates are:

std/math.d(4171):        std.math.isNaN(X)(X x) if
(isFloatingPoint!X)
----

Is there a way I can to do this, maybe opCall/opCast (I tried
these but failed)?

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

Thanks for the info. I'm happy to change my code and remove the implicit conversion. It was just for a convenience factor (floats with accumulated error).


Cheers,
uri

Reply via email to