Re: Is there a cleaner way of doing this?

[Ali Çehreli via Digitalmars-d]

On 08/07/2017 01:01 AM, 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?

A mixin template can work. The whole param-related code is in one place 
and the void specialization obviates the need for static if:

mixin template ParamCode(T) {
    T param;

    void initializeParam(T param) {
        this.param = param;
        initialize();
    }
}

template ParamCode(T : void) {
}

struct S(T) {
    mixin ParamCode!T;

    void initialize() {
        // ...
    }
}

unittest {
    auto a = S!int();
    static assert(a.sizeof == int.sizeof);
    a.initializeParam(42);

    auto b = S!void();
    static assert(b.sizeof == 1);
    b.initialize();
}

void main() {
}

Ali