Re: Is there a cleaner way of doing this?

[Timon Gehr via Digitalmars-d]

On 07.08.2017 10:01, Shachar Shemesh wrote:

It is often desired to have a struct with an extra parameter. The common way to do this is like so:

struct S(T) {
     T param;

     void initialize(T param) {
         this.param = param;
         // Other stuff
     }
}

The problem is what happens when the param is optional. The common way to do this is to set T to void. This results in the following code:

struct S(T) {
     enum HasParam = !is(T == void);
     static if( HasParam ) {
         T param;
     }

     static if( HasParam ) {
         void initialize(T param) {
             this.param = param;
             // Other stuff
         }
     } else {
         void initialize() {
             // Same other stuff as above!
         }
     }
}

This is both tedious and error prone. Is there a cleaner way of doing this?
...

struct S(T...) {
    T param;

    void initialize(T param) {
        this.param = param;
        // Other stuff
    }
}

Then, use S!() instead of S!void.

Just as an unrealistic fantasy, if the following code was legal, the problem would be resolved on its own:

void func(void p) {
     void param;

     param = p;

     return param;
}

Of course, that code has its own set of problems, and I'm not really suggesting that change.

Shachar

The only reason this code is problematic is that void.sizeof == 1.