Someone can suggest me a convenient way to declare an 'isNaN' templated function that plays well with the 'standard.math.isNaN'?

The target is to be able to define isNaN functions for my custom structures, and I want to keep the same name...

---
import std.math;

bool isNaN(T)(T t) if(is(T==string)){ return true; }

// that is really necessary? What if I have my isNaN in different modules? Must duplicate?
// bool isNaN(T)(T t) if(is(T:real)) { return std.math.isNaN(t); }

void foo(){
	bool b = isNaN(0.0);
}

/d471/f783.d(9): Error: template f783.isNaN does not match any function template declaration. Candidates are:
/d471/f783.d(3):        f783.isNaN(T)(T t) if (is(T == string))
/d471/f783.d(9): Error: template f783.isNaN(T)(T t) if (is(T == string)) cannot deduce template function from argument types !()(double)
---

Thanks in advance!

- Paolo Invernizzi

Hello all,

Suppose that I have a struct like e.g.:

    struct A
    {
        void foo(int n) { ... }
        void foo(Range)(Range r) { ... }
        int bar() { ... }
        int bar(double x) { ... }
        // ... and others ...
    }

... an I want to wrap it in another struct, B.  If I do this manually it would be something like,

    struct B
    {
        private A a;
        void foo(int n) { return a.foo(n); }
        void foo(Range)(Range r) { return a.foo(r); }
        // ... etc ...
    }

But suppose that I don't a priori know the list of functions (and function arguments) that need to be wrapped.  How could I go about working this out, with a generic programming approach?

More specifically, how could I work this out limited to a specific function of A (say, foo) ... ?

Thanks & best wishes,

    -- Joe

Whoops -- must have accidentally hit "Reply" there by accident, instead of clicking to send new mail.  Didn't mean to hijack someone else's thread. :-(

On Saturday, 24 August 2013 at 12:12:29 UTC, Joseph Rushton Wakeling wrote:

Hi Joseph,

I'm not really a D guru like others, but...

> ... an I want to wrap it in another struct, B.  If I do this manually it would be something like,
>
>     struct B
>     {
>         private A a;
>         void foo(int n) { return a.foo(n); }
>         void foo(Range)(Range r) { return a.foo(r); }
>         // ... etc ...
>     }
>
> But suppose that I don't a priori know the list of functions (and function arguments) that need to be wrapped.  How could I go about working this out, with a generic programming approach?

For this case I would use alias this, if you want to wrap every method...

    struct B
    {
        private A a;
        alias a this;
    }

> More specifically, how could I work this out limited to a specific function of A (say, foo) ... ?

I think that you have to explicitly wrap them, maybe with a template to alleviate the copy/past...
But maybe someone else can suggest a better solution!

- Paolo Invernizzi

On 24/08/13 13:53, Paolo Invernizzi wrote:
> Someone can suggest me a convenient way to declare an 'isNaN' templated function
> that plays well with the 'standard.math.isNaN'?
>
> The target is to be able to define isNaN functions for my custom structures, and
> I want to keep the same name...

Will this do?

//////////////////////////////////////

import std.math, std.traits;

bool isNaN(T)(T t)
{
    static if (isNumeric!T)
    {
        return std.math.isNaN(t);
    }
    else
    {
        return true;
    }
}

unittest
{
    assert(isNaN("NaN"));
    assert(!isNaN(0));
    assert(!isNaN(0.0));
    assert(isNaN(real.nan));
}

//////////////////////////////////////

Since you were kind enough to answer my accidental response to your mail, I thought I'd try and return the favour ... ;-)

On 24/08/13 14:50, Joseph Rushton Wakeling wrote:
>      static if (isNumeric!T)
>      {
>          return std.math.isNaN(t);
>      }

Note that the correct if () condition here depends on how you want your isNaN to behave in certain cases.  Using isNumeric will mean isNaN('c') returns true.  If you want isNaN to return false when passed a char type, use your if(is(T : real)) instead.