tupleof works for struct and class instances, but explicitly documents that it ignores instance variables from any superclass.

Is there any way to enumerate all the instance variables, not just the ones present in the specific instance's class?

Thanks,
Andy

On Friday, 27 June 2025 at 22:33:25 UTC, Andy Valencia wrote:

__traits(allMembers but it wont be useful, and youll need to find some other filter, etc. etc.

On Friday, 27 June 2025 at 22:33:25 UTC, Andy Valencia wrote:

This is one way:

import std;

class C
{
    int x, y;
}

class D : C
{
    int a, b;
}

void main()
{
    D d = new D;
    static if (is(D Bases == super))
    {
        static foreach (B; AliasSeq!(D, Bases))
        {
            pragma(msg, B);
            static foreach (field; B.tupleof)
            {{
                enum s = __traits(identifier, field);
                pragma(msg, s);
                // access runtime field
                __traits(getMember, d, s)++;
            }}
        }
    }
    assert([d.tupleof, (cast(C)d).tupleof] == [1,1,1,1]);
}

Pragma output:

D
a
b
C
x
y

On Saturday, 28 June 2025 at 10:41:47 UTC, Nick Treleaven wrote:

static if (is(D Bases == super))

Wow. I can't find that in any of my references on D... including the language spec itself. Nor in Phobos source... what is a "D Bases", please? Uncle!

Andy

On Sunday, 29 June 2025 at 03:50:03 UTC, Andy Valencia wrote:

static if (is(D Bases == super))

Ali's given a great answer, I'll just add that there's a Phobos trait I could've used which reads better and avoids the initial static if nesting (where the condition is always true):

alias Bases = BaseClassesTuple!D;

That also avoids listing any interfaces the class may implement.

https://dlang.org/phobos/std_traits.html#BaseTypeTuple

On Saturday, 28 June 2025 at 10:41:47 UTC, Nick Treleaven wrote:

        static foreach (field; B.tupleof)
        {{
            enum s = __traits(identifier, field);
            pragma(msg, s);
            // access runtime field
            __traits(getMember, d, s)++;
        }}

One last question, if you would? Why the double open braces? I tried, and got:

tst57.d(26): Error: declaration tst57.main.s is already defined
tst57.d(26): variable s is defined here

if I changed to a single open brace?

Thanks again,
Andy

On Monday, 30 June 2025 at 16:37:01 UTC, Andy Valencia wrote:

        static foreach (field; B.tupleof)
        {{
            enum s = __traits(identifier, field);
            pragma(msg, s);
            // access runtime field
            __traits(getMember, d, s)++;
        }}

the static foreach will emit all code in scope, which means each iteration will emit the code in the scope, so you double brace it to create individual scopes that don't "overlap".