On Tuesday, 17 January 2023 at 02:45:30 UTC, TheZipCreator wrote:
> 	default this(float x, float y, float z);

Try this out:

class Foo {
        int x;
        int y;
        int z;

        // one little function
        this(typeof(this.tupleof) t) {
                this.tupleof = t;
        }
}

void main() {
        auto foo = new Foo(1, 2, 3);
        assert(foo.x == 1);
        assert(foo.y == 2);
        assert(foo.z == 3);
}

On Tuesday, 17 January 2023 at 03:12:09 UTC, Adam D Ruppe wrote:
> On Tuesday, 17 January 2023 at 02:45:30 UTC, TheZipCreator wrote:
>> 	default this(float x, float y, float z);
>
> Try this out:
>
> class Foo {
>         int x;
>         int y;
>         int z;
>
>         // one little function
>         this(typeof(this.tupleof) t) {
>                 this.tupleof = t;
>         }
> }
>
> void main() {
>         auto foo = new Foo(1, 2, 3);
>         assert(foo.x == 1);
>         assert(foo.y == 2);
>         assert(foo.z == 3);
> }

ooh, that's an interesting usage of `tupleof`. I didn't even know it could be used as an lvalue. This is a bit unclear if you don't know the internals of D though. also, this wouldn't work if you just want to initialize one or two values and not all of them, but still could be useful.

On Tue, Jan 17, 2023 at 03:12:09AM +0000, Adam D Ruppe via Digitalmars-d wrote: [...]
> class Foo {
>         int x;
>         int y;
>         int z;
> 
>         // one little function
>         this(typeof(this.tupleof) t) {
>                 this.tupleof = t;
>         }
> }
[...]

Very nice!  Gotta use this in my own code sometime. :-D


T

-- 
Life is too short to run proprietary software. -- Bdale Garbee

On 1/16/23 19:12, Adam D Ruppe wrote:
>          // one little function
>          this(typeof(this.tupleof) t) {
>                  this.tupleof = t;
>          }

Which can be mixed-in and can have default arguments:

mixin template memberAssigningConstructor() {
    // one little function
    this(typeof(this.tupleof) t = typeof(this.tupleof).init) {
        this.tupleof = t;
    }
}

import std.stdio;

class Foo {
    int x;
    int y;
    int z;

    mixin memberAssigningConstructor!();

    override string toString() const {
        import std.format : format;
        return format!"%s %s %s"(x, y, z);
    }
}

void testWith(Args...)(Args args) {
    auto f = new Foo(args);
    writeln(f);
}

void main() {
    testWith();
    testWith(1);
    testWith(1, 2);
    testWith(1, 2, 3);
}

Outputs:

0 0 0
1 0 0
1 2 0
1 2 3

However, I recommend testing compilation speeds because I used mixed-in tupleof for opCmp implementations in a project about 3 years ago. There were only 6 instances of that usage but the compilation times were noticeably affected. (Disclaimer: There were 6 instances but I think those modules were imported very many times by other modules.)

Replacing the tupleof idiom with trivial functions fixed the compilation speed issue for me.

Ali