Code:

import std.stdio;

struct Field {
    void opAssign(int a) {
        writefln("Field.opAssign(%s)", a);
    }
}

struct Register {
    Field clock(int a) {
        writefln("Register.clock(%s)", a);
        return Field();
    }
}


void main() {
    Register register;
    register.clock(1) = 10; // works, good
    register.clock = 10;    // works too, how to disable it?
}

How to disable register.clock = 10; but allow register.clock(1) = 10;?
I want to get a compilation error on register.clock = 10;

On Tuesday, 6 July 2021 at 10:06:11 UTC, Jack Applegame wrote:

We're still awaiting formal assessment on dip1038, but if that gets in, you can mark clock or Field @nodicard. Otherwise I don't know of a way.

On Tuesday, 6 July 2021 at 10:25:28 UTC, Dennis wrote:

Yes, it would help.

On Tuesday, 6 July 2021 at 10:06:11 UTC, Jack Applegame wrote:

You don't. The language always allows a = b; to be rewritten as a(b);.

Best you can do is use different types for the two arguments. Maybe clock could take a struct Clock { int x; } or something instead.

On Tuesday, 6 July 2021 at 12:33:20 UTC, Adam D Ruppe wrote:

And that's sad. It should happen for properties only.

On Tuesday, 6 July 2021 at 13:27:43 UTC, Jack Applegame wrote:

Totally disagree. This is one of my favorite D features.

On 7/6/21 9:27 AM, Jack Applegame wrote:

Yes, I lament that there is no way to control how people call your function. It can result in surprising things, and it means as a library designer you have to consider this usage when picking names.

There are a few "draft" DIP proposals (under the old DIP system) here: https://wiki.dlang.org/DIPs

But I think the time of being able to make such a disruptive change has passed. For better or worse we have the half-implemented near-useless meaning of @property, and basically it's unneeded.

-Steve

On Tuesday, 6 July 2021 at 10:06:11 UTC, Jack Applegame wrote:

Some options:

1. return a temporary struct with an opIndex

import std.stdio;

struct Field {
    void opAssign(int a) {
        writefln("Field.opAssign(%s)", a);
    }
}

struct ClockAssign {
    Field opIndex(int a) {
        writefln("Register.clock(%s)", a);
        return Field();
    }
}

struct Register {
    ClockAssign clock() {
        return ClockAssign();
    }
}

void main() {
    Register register;
    register.clock[1] = 10; // works, good
    //register.clock = 10; // error
}

2. https://run.dlang.io/is/bkV64U - keep track of fields and fail at runtime if a field was never initialized (because it was silently discarded in this case).

3. https://run.dlang.io/is/AJM6Vg - hybrid where ClockAssign has an unsafe pointer that the compiler complains about :/