P4033R0
Synthesizing enum at compile time with define_enum

1. Motivation

The generative capability of reflection as they were introduced in C++26 are limited to define_aggregate, with no quick paths to more powerful facilities (See [p3294r2] for example). We can already leverage define_aggregate to impressive effects (See a JSON parser here), here we introduce another basic and lightweight building block: define_enum.

enum-based variant
Using define_enum() we can simulate some enum-based discriminant variant

template<class... Ts>
struct named_variant_T {
  std::variant<Ts...> v;

  enum class kind : std::size_t;
  consteval {
      std::vector<std::meta::info> enumerators;
      for (auto type : {^^Ts...}) {
          enumerators.push_back(enumerator_spec({
            .name = std::define_static_string(identifier_of(type))
          }));
      }
      enumerators.push_back(enumerator_spec({.name = "Default"}));
      define_enum(^^kind, enumerators);
  }

  constexpr kind which() const noexcept {
    auto i = v.index();
    if (i == std::variant_npos) return kind::Default;
    return static_cast<kind>(i);
  }
  // ...
};

using Message = named_variant_T<X, Y, Z>;

This unlocks a variant that has some favorable properties
Looking at a simple example of non-visit() based access

using VarPet = std::variant<Dog, Tanuki, Cat>;
// To keep in sync
enum VariantPetIndex {
  Dog,
  Tanuki,
  Cat,
};
//...
VarPet animal(Dog{});
// ...
switch (animal.index()) {
  default: break;
  case VariantPetIndex::Dogs break;
  case VariantPetIndex::Tanuki: break;
  case VariantPetIndex::Cats break;
}

using VarPet = named_variant_T<Dog, Tanuki, Cat>;
//...
VarPet animal(Dog{});

switch (animal.which()) {
  case VarPet::kind::Default: break;
  case VarPet::kind::Dog: break;
  case VarPet::kind::Tanuki: break;
  case VarPet::kind::Cats break;
}

1. It is considerably more verbose

2. switch tables lend themselves easily to jump table dispatch (which is fast, which is nice)

See this example where we also leverage annotations on enumerators.

2. What about unscoped enum ?

Note that above, we made the explicit choice of targetting scoped enumeration only, and so the following is not valid

enum HealthySnacks: int;
consteval {
  define_enum(^^HealthySnacks, {
    enumerator_spec({.name = "Carrot"}),
    enumerator_spec({.name = "Celeri"}),
    enumerator_spec({.name = "BabaAuRhum"})
  });
}

// From here on out BabaAuRhum == 2

3. Feature

The actual feature proposed here is define_enum(), allowing to complete an opaque scoped enumeration alongside the description of its enumerators. In turn, define_enum relies on a lightweight description of the enumerators (enumerator options), that are passed to enumerator_spec().
All those pieces will be described here, ultimately it should feel familiar to any define_aggregate() enthusiast.

3.1. enumerator_options

template<integral I>
struct enumerator_options {
  string       name;
  optional<I>  value       = {};
  vector<info> annotations = {};
  vector<info> attributes  = {};
};

As when defining manually an enumerator, the integral value is optional. If ommited it will be computed in the same fashion that is done already (incrementing previous value). Diverging with the original design of define_aggregate(), annotations and attributes are directly supported here via .annotations and .attributes.
Finally note that the support for .attributes here relies entirely on the adoption of attributes reflection via [p3385r7].

3.2. enumerator_spec

consteval info enumerator_spec(enumerator_options props);

3.3. is_enumerator_spec

consteval bool is_enumerator_spec(info r);

3.4. define_enum

template <reflection_range R = initializer_list<info>>
    consteval info define_enum(info targetEnum, R&& members);

4. Wording

4.1. Library

4.1.1. Meta synopsis [meta.syn]

namespace std {
  // ... 


  // [meta.reflection.define.enum], enum definition generation

  template<integral I> struct enumerator_options;

  consteval info enumerator_spec(enumerator_options options);

  consteval bool is_enumerator_spec(info r);

  template <reflection_range R = initializer_list<info>>
    consteval info define_enum(info targetEnum, R&& members);

4.1.2. Reflection union definition generation [meta.reflection.define.enum]

namespace std::meta {
  template<integral I>
  struct enumerator_options {
    optional<string> name = std::nullopt;
    optional<I> value = {};
    vector<info> attributes = {};
    vector<info> annotations = {};
  };
}
consteval info enumerator_spec(enumerator_options options);

consteval bool is_enumerator_spec(info r);

template <reflection_range R = initializer_list<info>>
  consteval info define_enum(info targetEnum, R&& members);

5. Status

6. Acknowledgements