Enum class improvements for C++17, C++20 and C++23

    enum class Handle : uint32_t { Invalid = 0 }; 
    Handle h { 42 }; // OK

One of their examples demonstrates the number one issue for me with enums, which was not fixed with `enum class`. Since values outside the range of the type are valid, you are constantly needing to check for invalid values in any function that takes an enum [class]. Ruins any attempt at "parse, don't validate" style in c++ and completely ruins the "type safety" which c++ people are always going on about.

Union, inheritance, dynamic_cast, enum class, std::variant... when all we needed all along was proper sum types.

> C++20 introduced the `using enum` syntax, which enhances the usability of enums

Out of context, this is a very funny thing to say.

    enum class Handle : uint32_t { Invalid = 0 }; 
    // process({10}); // error
    process(Handle{10});

> In C++14, you could use process(static_cast<Handle>(10)); so, as you can see, the C++17 version is much better.

100% disagree that the c++17 version is better. It just lets you right broken code that doesn't look broken.

Odd that it says

  auto value = std::to_underlying(p); // C++23

is "more expressive" than

  uint8_t value = static_cast<uint8_t>(Permissions::Read);

The latter seems clearly more expressive, not less. You could tighten it up a bit by using auto on the LHS instead of the redundant uint8_t. In the former I don't know what's going on and I have to go read another header to figure out the type of `value`.

Speaking of enums, what's a better serialization framework for C++ like Serde in Rust, and then what about Linked Data support and of course also form validation.

Linked Data triples have (subject, predicate, object) and quads have (graph, subject, predicate, object).

RDF has URIs for all Subjects and Predicates.

RDF Objects may be URIs or literal values like xsd:string, xsd:float64, xsd:int (32bit signed value), xsd:integer, xsd:long, xsd:time, xsd:dateTime, xsd:duration.

RDFS then defines Classes and Properties, identified by string URIs.

How best to get from an Enum with (type,attr, {range of values}) to an rdfs:range definition in a schema with a URI prefix?

Python has dataclasses which is newer than attrs, but serde also emits Python pickles

It's too bad that using enum is not emplicit for the cases in switch statements.

How many meanings of the word emum do we need? Whose code does this improve?

All that crap is the reason I never bother with enums in all these C like languages

     set_player_color(player, .RED);

That should be the way to use them, it's concise and typesafe

    set_color(Color::RED);

Why repeat yourself?

It's one of the things I love about Swift and Zig

    int main() {
        using enum ComputeStatus;
        ComputeStatus s = NotEnoughMemory;
    }

now you have polluted the scope.. C++ have lost the plot.. they understood the issue, but they came up with a solution that's worse...

Reflection is going to be a game-changer for C++. Finally!

I don’t feel like it’s an improvement. Personally prefer the explicit enum usage.

Imagine still using c++ in 2024 lmao.