Good day,

It's hard to find good examples of the c++ reflection ts so I've copied one I've found in an earlier proposal
I am just putting the proposed c++ syntax here, next to how my core.reflect library would handle this case.

#include <meta>
template<Enum T>
std::string to_string(T value) { // Could also be marked constexpr
    for constexpr (auto e : std::meta::members_of(reflexpr(T)) {
        if (exprid(e) == value) {
            return std::meta::name_of(e);
        }
    }
    return "<unnamed>";
}

import core.reflect.reflect;
string toString(E)(E enumValue)
{
    static immutable ed = cast(EnumDeclaration)nodeFromName(E);
    foreach(m; ed.members)
    {
        if ((cast(IntegerLiteral)m.value).value == enumValue)
        {
            return m.name;
        }
    }
    return "unnamed";
}

Please let know what you think.

On Sunday, 26 September 2021 at 19:03:24 UTC, Stefan Koch wrote:

Ugh typo.

is supposed to be:

static immutable ed = cast(EnumDeclaration)nodeFromName("E");

On Sunday, 26 September 2021 at 19:09:31 UTC, Stefan Koch wrote:

What about E.stringof? Instead of hardcoding names :) Not sure if stringof will return E in all cases, so obviously only if it works.

On Monday, 27 September 2021 at 06:25:07 UTC, bauss wrote:

E stringof would return the name of the type;
In simple cases and garbage in others.

Whereas the name E always refers to the type used in the toString template.
Also "E" is less typing than E.stringof

On Monday, 27 September 2021 at 07:28:46 UTC, Stefan Koch wrote:

Yeah I figured it wouldn't work that easily.

In this case yeah "E" wouldn't be a problem but if it was "ThisTypeName" you might end up with a typo.

On Monday, 27 September 2021 at 07:32:48 UTC, bauss wrote:

Yes, but you can typo ThisTypeName whether you type it with quotes around it or without.
It's still an identifier. Which may not be Identifying anything if it's mistyped.
The reason why I am using a string is that I wanted to avoid having to introduce a special expression. see c++ reflexpr

On Monday, 27 September 2021 at 08:39:45 UTC, Stefan Koch wrote:

If it's mistyped, the compiler will complain that it doesn't exist

When it's an identifier, IDE refactorings (automated renaming) will find it, while it wouldn't find it in a string, especially the more generic the name is (which is common for template types T)

C# has nameof(T) which just returns "T" or for nameof(Foo.T) it also just returns "T"

On Monday, 27 September 2021 at 13:12:32 UTC, WebFreak001 wrote:

core.reflect will tell you that you tried to resolve a name which does not exist as well.

That's valid.
I have to think about what to do about that.
Maybe remove the "" for the refactoring?
a simple search for nodeFromName\(\"$ID\"\) maybe?
It's the only primitive in code reflect which does this.

using traits:

string enum_to_str(E)(E v) if (is(E == enum))
{
    final switch (v) with(E)
    {
        static foreach (m; __traits(allMembers, E))
        {
    case mixin(m):
            return m;
        }
    }
}

core.reflect is nicer than traits because you actually get to use actual D code

But the casting is kinda ugly, and it gives me java nightmares.. so the C++ actually feels much better

On Monday, 27 September 2021 at 13:12:32 UTC, WebFreak001 wrote:

Yeah, I really wish we had an alternative to stringof like nameof. I often forgot that aliases don't work well with it, as displayed here :)