www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - How to assert a function signature in D2.008?

reply "Janice Caron" <caron800 googlemail.com> writes:
This used to compile under D2.007

    struct A
    {
        void f() {}

        static assert(is(typeof(f)==void function()));
    }

It doesn't under D2.008. The only way I've found to make it compile
under D2.008 is to change it to

    struct A
    {
        void f() {}

        static assert(is(typeof(f)==function));
    }

which means I am no longer able to check the function signature. So,
the question is, /how/ do I check the function signature in D2.008? I
know I could use ReturnType! and ParameterTypeTuple!, but that would
be so tedious for functions with more complex signatures. For example:

    struct A
    {
        int f(int,char,float,int) {}

        static assert(is(typeof(f)==function));
        static assert(is(ReturnType!(f) == int));
        static assert(ParameterTypeTuple!(f).length == 4);
        static assert(is(ParameterTypeTuple!(f)[0] == int));
        static assert(is(ParameterTypeTuple!(f)[1] == char));
        static assert(is(ParameterTypeTuple!(f)[2] == float));
        static assert(is(ParameterTypeTuple!(f)[3] == int));
    }

Is this really the "right" way to do things now? The old (D2.007) way
let me make that check in a single line.
Dec 04 2007
next sibling parent Christopher Wright <dhasenan gmail.com> writes:
Janice Caron wrote:
 This used to compile under D2.007
 
     struct A
     {
         void f() {}
 
         static assert(is(typeof(f)==void function()));
     }
 
 It doesn't under D2.008. The only way I've found to make it compile
 under D2.008 is to change it to
 
     struct A
     {
         void f() {}
 
         static assert(is(typeof(f)==function));
     }
 
 which means I am no longer able to check the function signature. So,
 the question is, /how/ do I check the function signature in D2.008? I
 know I could use ReturnType! and ParameterTypeTuple!, but that would
 be so tedious for functions with more complex signatures. For example:
 
     struct A
     {
         int f(int,char,float,int) {}
 
         static assert(is(typeof(f)==function));
         static assert(is(ReturnType!(f) == int));
         static assert(ParameterTypeTuple!(f).length == 4);
         static assert(is(ParameterTypeTuple!(f)[0] == int));
         static assert(is(ParameterTypeTuple!(f)[1] == char));
         static assert(is(ParameterTypeTuple!(f)[2] == float));
         static assert(is(ParameterTypeTuple!(f)[3] == int));
     }
 
 Is this really the "right" way to do things now? The old (D2.007) way
 let me make that check in a single line.

static assert (is (typeof(&f) == typeof(delegate void (int, char, float, int){}))); I don't know how to write the type of a delegate so that it can be used in an is expression.
Dec 04 2007
prev sibling parent reply Walter Bright <newshound1 digitalmars.com> writes:
Janice Caron wrote:
 This used to compile under D2.007
 
     struct A
     {
         void f() {}
 
         static assert(is(typeof(f)==void function()));
     }
 
 It doesn't under D2.008. The only way I've found to make it compile
 under D2.008 is to change it to

Change it to: is(typeof(&f)==void function())
Dec 04 2007
parent reply Sean Kelly <sean f4.ca> writes:
Walter Bright wrote:
 Janice Caron wrote:
 This used to compile under D2.007

     struct A
     {
         void f() {}

         static assert(is(typeof(f)==void function()));
     }

 It doesn't under D2.008. The only way I've found to make it compile
 under D2.008 is to change it to

Change it to: is(typeof(&f)==void function())

I guess the reason that this matches "void function" rather than "void delegate" is to avoid the need for handling each separately? Sean
Dec 04 2007
parent reply "Craig Black" <cblack ara.com> writes:
"Sean Kelly" <sean f4.ca> wrote in message 
news:fj4e63$1jaa$1 digitalmars.com...
 Walter Bright wrote:
 Janice Caron wrote:
 This used to compile under D2.007

     struct A
     {
         void f() {}

         static assert(is(typeof(f)==void function()));
     }

 It doesn't under D2.008. The only way I've found to make it compile
 under D2.008 is to change it to

Change it to: is(typeof(&f)==void function())

I guess the reason that this matches "void function" rather than "void delegate" is to avoid the need for handling each separately? Sean

To me this is confusing because you are taking the address of an instance function without specifying the context pointer. It doesn't result in a delegate but it shouldn't result in a function either. Maybe there should be another type for "delegate without context pointer". -Craig
Dec 05 2007
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Craig Black" wrote
 "Sean Kelly" <sean f4.ca> wrote in message 
 news:fj4e63$1jaa$1 digitalmars.com...
 Walter Bright wrote:
 Janice Caron wrote:
 This used to compile under D2.007

     struct A
     {
         void f() {}

         static assert(is(typeof(f)==void function()));
     }

 It doesn't under D2.008. The only way I've found to make it compile
 under D2.008 is to change it to

Change it to: is(typeof(&f)==void function())

I guess the reason that this matches "void function" rather than "void delegate" is to avoid the need for handling each separately? Sean

To me this is confusing because you are taking the address of an instance function without specifying the context pointer. It doesn't result in a delegate but it shouldn't result in a function either. Maybe there should be another type for "delegate without context pointer". -Craig

It is consistent with other uses of typeof. typeof is a special compiler directive that says "give me the type of what this instruction would be". It doesn't actually execute the instruction. And I believe the 'is' operation must be executed by the compiler at compile time anyways. -Steve
Dec 05 2007
next sibling parent reply Sean Kelly <sean f4.ca> writes:
Steven Schveighoffer wrote:
 "Craig Black" wrote
 "Sean Kelly" <sean f4.ca> wrote in message 
 news:fj4e63$1jaa$1 digitalmars.com...
 Walter Bright wrote:
 Janice Caron wrote:
 This used to compile under D2.007

     struct A
     {
         void f() {}

         static assert(is(typeof(f)==void function()));
     }

 It doesn't under D2.008. The only way I've found to make it compile
 under D2.008 is to change it to

is(typeof(&f)==void function())

delegate" is to avoid the need for handling each separately? Sean

function without specifying the context pointer. It doesn't result in a delegate but it shouldn't result in a function either. Maybe there should be another type for "delegate without context pointer".

It is consistent with other uses of typeof. typeof is a special compiler directive that says "give me the type of what this instruction would be". It doesn't actually execute the instruction.

So because &f doesn't involve an instance, the compiler just makes it a function pointer rather than a delegate, regardless of whether the function is static? I suppose that makes sense. Sean
Dec 05 2007
parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Sean Kelly" wrote
 Steven Schveighoffer wrote:
 "Craig Black" wrote
 "Sean Kelly" wrote in message
 I guess the reason that this matches "void function" rather than "void 
 delegate" is to avoid the need for handling each separately?


 Sean

instance function without specifying the context pointer. It doesn't result in a delegate but it shouldn't result in a function either. Maybe there should be another type for "delegate without context pointer".

It is consistent with other uses of typeof. typeof is a special compiler directive that says "give me the type of what this instruction would be". It doesn't actually execute the instruction.

So because &f doesn't involve an instance, the compiler just makes it a function pointer rather than a delegate, regardless of whether the function is static? I suppose that makes sense.

I was responding to Craig's confusion as to using typeof with an invalid instance :) I, like you, think it should be delegate instead... -Steve
Dec 05 2007
prev sibling parent "Craig Black" <cblack ara.com> writes:
"Steven Schveighoffer" <schveiguy yahoo.com> wrote in message 
news:fj6par$2gkq$1 digitalmars.com...
 "Craig Black" wrote
 "Sean Kelly" <sean f4.ca> wrote in message 
 news:fj4e63$1jaa$1 digitalmars.com...
 Walter Bright wrote:
 Janice Caron wrote:
 This used to compile under D2.007

     struct A
     {
         void f() {}

         static assert(is(typeof(f)==void function()));
     }

 It doesn't under D2.008. The only way I've found to make it compile
 under D2.008 is to change it to

Change it to: is(typeof(&f)==void function())

I guess the reason that this matches "void function" rather than "void delegate" is to avoid the need for handling each separately? Sean

To me this is confusing because you are taking the address of an instance function without specifying the context pointer. It doesn't result in a delegate but it shouldn't result in a function either. Maybe there should be another type for "delegate without context pointer". -Craig

It is consistent with other uses of typeof. typeof is a special compiler directive that says "give me the type of what this instruction would be". It doesn't actually execute the instruction. And I believe the 'is' operation must be executed by the compiler at compile time anyways. -Steve

Ok, that makes sense.
Dec 05 2007