Additional features for flags enums

[RobertRiojaAlpa]

Hello,

I have some suggestions for features I've come across so far that'd be nice to have.

1. For flags enums, a MyEnumExtensions.All field that resolves to a bitwise OR of every value would be very useful, no longer requiring the user to define one for many situations. This also prevents the Length field from being inaccurate in such a case.
2. Also related, adding an ExcludeFromLength boolean field to the EnumMemberAttribute could be useful. All occurrences of it would be counted and subtracted from Length.
3. For all enums, myEnum.Next() and myEnum.Previous() are commonly implemented and could instead be generated. To be more thorough, an ExcludeFromPreviousNext field could be added to EnumMemberAttribute as well.

Thanks

[RobertRiojaAlpa]

Other useful additions:

1. For flag enums, myEnum.GetLowestSetBit() and myEnum.GetHighestSetBit(). Getting the lowest set bit is simply
   (MyEnum) (((int) myEnum) & -((int) myEnum))
2. For any enum, MyEnumExtensions.Max() and MyEnumExtensions.Min() to get the largest and smallest value. For enums without a custom value this would be equal to Length

[andrewlock]

Hi @RobertRiojaAlpa, thanks for the suggestions!

The MyEnumExtensions.All option is certainly an interesting one, and is obviously pretty easy to implement, but it kind of goes against all the "prior art" in the BCL for enums, so I'm not entirely sold 😅

To be honest, the others, I'm not sure about, they seem pretty niche 🤔

adding an ExcludeFromLength boolean field to the EnumMemberAttribute could be useful. All occurrences of it would be counted and subtracted from Length.

EnumMemberAttribute is a BCL type so we can't modify it

For all enums, myEnum.Next() and myEnum.Previous() are commonly implemented and could instead be generated

Are they? 😅 I've never seen them implemented in any codebase I've worked in (anecdotal obviously, just wondering when you would use these?)

For flag enums, myEnum.GetLowestSetBit() and myEnum.GetHighestSetBit(). Getting the lowest set bit is simply
(MyEnum) (((int) myEnum) & -((int) myEnum))

If I understand correctly, this may be better implemented as a completely generic helper method? e.g.

public static class EnumHelpers
{
    public T GetLowesetSetBit(this T value)
    where T : Enum 
      => (T) (((int) value) & -((int) value));
}

I'm not sure those are a great fit for this library, they seem very specialized whereas the library is meant to be much higher level, providing fast replacements for BCL methods...

The Max() and Min()` ones seem ok on the surface, but they don't really sit right to me 🤔 I think it's because (like the other suggestions) they're very much focused on the underlying storage values of the enums, as opposed to treating enums as more "opaque" types, which is more like how they're generally intended... I totally understand why you would want to 'abuse' them in this way, I'm just not sure that this library is the right place to put them 🤔

[RobertRiojaAlpa]

Thanks for the reply!

I only just discovered this project so I'm not familiar with its ethos per se. That said, I'll make my case!

I wouldn't think the only point of EnumGenerators is simply to provide faster implementations of BCL methods. I might look towards FastEnum for that. I actually found this library looking for a cleaner and faster way to get string values from my enums. The benefit of this library supporting metadata string values is to avoid abandoning enums for string consts or retrieving via reflection. I'd argue many of my suggestions help avoid the same fate.

My use cases:

enum MyEnum {
    Value1 = 1 << 0,
    Value2 = 1 << 1,
    Value3 = 1 << 2,
}

class Test(MyEnum DefaultValue = ?, MyEnum AllowedValues = ?) {
...
}

The problem I run into is what to set as the default values for the two primary constructor variables. I want the user to be able to supply DefaultValue and/or AllowedValues and if not, DefaultValue should be the first enum value and AllowedValues should be any enum value. What I'd like to do is:

MyEnum DefaultValue = MyEnumExtensions.Min, MyEnum AllowedValues = MyEnumExtensions.All

and to make sure DefaultValue is in AllowedValues:

if(!AllowedValues.HasFlagFast(DefaultValue)) {
    DefaultValue = AllowedValues.MinFlag(); //This is what I previously called GetLowestSetBit
}

Where both Min and All are constants. As it stands with EnumGenerators, I have to instead make sure MyEnum starts at 1 instead of 0 and do:

class Test() {
    Test([Optional] MyEnum defaultValue, [Optional] MyEnum allowedValues) {
        if(defaultValue == default) {
            defaultValue = MyEnum.GetValues().Min();
        }

        if(allowedValues == default) {
            allowedValues = MyEnum.GetValues().Aggregate((a, b) => a | b);
        }

        if(!allowedValues.HasFlagFast(defaultValue)) {
            defaultValue = (MyEnum) (((int) allowedValues) & -((int) allowedValues));
        }
    ...
    }
...
}

Note that I use [Optional] here to avoid setting a default value, as there's no way to know what that would be at compile time

Now say I want a button that cycles through MyEnum values. What I'd like to do is:

var nextValue = myEnum.Next()

Instead, for non-flag enums I have to do:

var nextValue = (MyEnum) (((int) (myEnum + 1)) % MyEnumExtensions.Length)

And for flag enums I have to do:

var nextValue = (MyEnum) (((int) nextValue) << 1);

if(((int) nextValue) >= 1 << MyEnumExtensions.Length) {
    nextValue = MyEnum.GetValues().Min();
}

The addition of these methods/constants would save me from using Linq functions or looping myself, which does lead to performance improvements. All of this may still not match the purpose of the project and some of these could be generic enum extensions, but I hope the examples I've provided help explain their usefulness.

[andrewlock]

Thanks for all the details, that's very useful!

I wouldn't think the only point of EnumGenerators is simply to provide faster implementations of BCL methods

Haha, that is actually literally what it was for 😄

I might look towards FastEnum for that.

Yeah, they were both created about the same time, for the same purpose, and both do pretty much the same thing 😄

I'll take a look through each of the suggestions in detail later, some of them definitely make more sense to me now, though they still do feel quite niche... I've been very hesitant adding new features to the library "just because I can", especially where there are simple alternatives that don't force everyone to deal with the noise of new methods etc, just to explain my push back 🙂

Anyway, I'll take another look through soon and get back to you!