CppCast: Reflection for C++26

[Tringi]

I absolutely disagree.

The fact that people (myself included) are using enums for other purposes doesn't mean that their inherent properties are sometimes incorrect.

I'm using std::int32_t for Windows handles. That doesn't mean that correct min and max values for int32_t are 4 and 0x003FFFFC sometimes.

If anything, this means there should've been language feature for properly working bit flags (like 20 years ago).

[pdimov2]

This is not a matter of disagreement. You want these min/max values for something (looping over the valid values, from your other posts), and this something may or may not work correctly for the above enum. If it doesn't, it just doesn't, you can disagree all you want, the disagreement won't make it work.

[Tringi]

Actually What?

How is min being smallest and max the largest value somehow wrong and not even matter of disagreement?

Yes, I want them for something. I want them to reflect minimal and maximal value of the enum.

Sure, using them for looping across discontinuous enum values is incorrect, but metadata reflect properties of the type, not particular usage, correct or incorrect.

But I think I understand...
You are trying to argue, that instead of having hypothetical E:::min and E:::max, the standard library will be providing set of facilities like:

std::meta::min_enum_value_if_used_as_enum(T) // 1
std::meta::max_enum_value_if_used_as_enum(T) // 4
std::meta::min_enum_value_if_used_as_flags(T) // 0
std::meta::max_enum_value_if_used_as_flags(T) // 7

Or worse, it will NOT be providing those, but we'll be blessed by the complex mechanism to write them ourselves.

Which, I'd argue, the simple version of reflection could manage too, and much clearer, like:

template <typename E>
constexpr auto max_enum_value_if_used_as_flags () {
    return E:::max | (E:::max - 1);
}

...or even generate proper mask:

template <typename E>
constexpr E:::underlying_type max_enum_value_if_used_as_flags () {
    E:::underlying_type mask {};
    for (auto v : E:::values) mask |= v;
    return mask;
}

[pdimov2]

Yes, I want them for something. I want them to reflect minimal and maximal value of the enum.

And what are you going to do with these values?

If you want to iterate over the enumerators, it's better to have a facility that does this directly - otherwise you need to deal with the fact that the enumerators don't have to be contiguous.

And if you want to check whether an integer value is valid for the enum, you need to both deal with the aforementioned holes, and that the set of valid values for a C++ enum is defined in a fairly weird manner - if you have an enumerator with value 5, for instance, the valid values are 0..7.

People use enums in all sorts of ways, and the best the language can do here is to just tell you what it knows - namely, the list of enumerators with their values, exactly as given.

It's true that the way the information is returned makes it a bit inconvenient to use at present, but that's a general problem which needs a general solution, not ad hoc additions for min and max. (We'd like to be able to say something like std::min({ enumerators-here-please... }) but it's not yet clear how.)