Pattern for working with Enum variants

[alexparlett]

Is your feature request related to a problem? Please describe.
Handling of enums feels relatively complex especially when working with things such as key codes, having to construct a variant, or convert to variant name and then do a string comparison makes our script api relatively unfriendly to users when considering things like modding etc.

i.e. with the input being KeyboardInput event.

function on_input(event)
    local key = event.key_code:variant_name()

    if (key == "KeyA") then
        info("move left")
    end
end

local KeyA = construct(types.KeyCode, {
  variant = "KeyA"
})

function on_input(event)
    if (event.key_code == KeyA) then
        info("move left")
    end
end

Describe the solution you'd like
A simpler way to handle enum variants, or even a well defined set of globals for bevy bindings (and a way for the user to easily define their own)

function on_input(event)
    if (event.key_code == KeyCode.KeyA) then
        info("move left")
    end
end

function on_input(event)
    if (event.key_code == keys.KeyA) then
        info("move left")
    end
end

Describe alternatives you've considered
This could be defined in a lua set of globals relatively easily.

keys = {
  KeyA = construct(types.KeyCode, {
    variant = "KeyA"
  })
}

Or register a global manually.

    registry.register("keys", move |wg: WorldGuard| {
        let allocator = wg.allocator();
        let mut allocator = allocator.write();

        let mut key_cache = HashMap::<String, ScriptValue>::default();
        for (key, name) in &key_codes {
            let payload = ReflectReference::new_allocated(*key, &mut allocator);

            key_cache.insert(name.to_string(), ScriptValue::Reference(payload));
        }

        Ok(ScriptValue::Map(key_cache))
    });

However this seems like an important binding to upstream if possible.

[makspll]

Definitely, iterating over all enums and generating something based on the variants is definitely doable, there are many options:

Global enum instances

• for unit variants, simply construct these variants as globals in the enum's namespace i.e. MyEnum.MyUnitVariant
• for for other variants, we could populate a constructor function for each variant i.e. MyEnum.SomeVariant({ foo = bar})

Global enum discriminators

• for all variants, register a discriminator type under the enum's global namespace, i.e. MyEnum.MyVariant
  • then add a :variant() function on all enums
  • allowing: my_enum_instance:variant() == MyEnum.MyVariant

Some combination of both

We might want bits of both of these functionalities, and in fact constructors as a whole could be made slightly more readable this way, then we would need to differentiate between constructors and discriminants, perhaps using: MyEnum.variants.MyVariant