Patterns for flag enums

[KryKomDev]

Patterns for flag enums

Summary

Introduce a has keyword for enum pattern matching, that would check if a specified enum flag is present in the checked instance. It could work the same as the Enum.HasFlag method, but it would make code more readable. This could be used in boolean conditions and mainly in switch statements and expressions. Syntax could be the same as of the normal pattens.

Examples

Consider the following enum:

[Flags]
public enum MyEnum {
    A = 1,
    B = 2,
    C = 4,
    D = 8,
    E = 16,
    F = 32,
    G = 64
}

Note

This enum is statically used in the examples below.

If statement

if (e has A and B and not C) { // equivalent to e.HasFlag(A) && e.HasFlag(B) && !e.HasFlag(C)
    ... 
}

Switch statement

switch(e) {
    case has A:
        ...
        break;
    case has B or C:
        ...
        break;
    case has D and E:
        ...
        break;
    case has F xor G:
        ...
        break;
    ...
}

Switch expression

e switch {
    has A => ...,
    has B or C => ...,
    has D and E => ...,
    has F xor G => ...,
    ...
};

Although this is not necessary, the xor keyword could be introduced alongside, to simplify some patterns. It would check if only one of the specified flags is present. For example e has A xor B would have to be written as e has A and not B || e has B and not A.

Motivation

This feature could enhance and simplify working with enums marked as a flag enum (using the FlagsAttribute) especially in switch statements and expressions. It could significantly increase the readability of these switch statements.

Currently, the simplest approach with switch statements looks like this:

switch (a) {
    case var _ when a.HasFlag(A):
        ...
        break;
    case var _ when a.HasFlag(B) || a.HasFlag(C):
        ...
        break;
    case var _ when a.HasFlag(D) && a.HasFlag(E):
        ...
        break;
    case var _ when a.HasFlag(F) ^ a.HasFlag(G):
        ...
        break;
    ...
}

or in the case of switch expressions:

a switch {
    _ when a.HasFlag(A) => ...,
    _ when a.HasFlag(B) || a.HasFlag(C) => ...,
    _ when a.HasFlag(D) && a.HasFlag(E) => ...,
    _ when a.HasFlag(F) ^ a.HasFlag(G) => ...,
    ...
};

[franchyd]

Flags in switch’s is weird to me because often flags don’t come with the implication of mutual exclusivity but switch cases do. This makes flags in a switch a potential pit of failure because it’s not clear from natural reading of the syntax that only one of the cases execute. One could argue that “everyone knows only one switch case executes” but even then this feature is limited to scenarios where you have only mutually exclusive flag processing, whereas non mutually exclusive flags do exist and are plentiful.

[franchyd]

So as it is today I would agree, but if a new special pattern were introduced (at least the way this proposal looks) it almost implies otherwise.
With this I totally agree, its clear, its a regular switch expression that happens to be running extra conditionals.

var a = A | B;
a switch {
    _ when a.HasFlag(A) => ...,
    _ when a.HasFlag(B) || a.HasFlag(C) => ...,
    ...
};

But when my mind reads this:

var e = A | B;
e switch {
    has A => ...,
    has B or C => ...,
    ...
};

The syntax makes it read like "e has A and B, so it should run both"

So I think that a has pattern would just confuse things in this situation.

[HaloFour]

I'd expect that case to be a compiler error, like it would be for checking object before string or other subsumed cases:

CS8510: The pattern is unreachable. It has already been handled by a previous arm of the switch expression or it is impossible to match.

That said, I'm not really in favor for specific language support for flags enums. I'd like to see that shake out of support for active patterns so that developers can write their own pattern functions.

[KryKomDev]

You are absolutely right in the case of switches, I didn't think of that, but couldn't this be introduced at least for normal boolean checks?

[ZlomenyMesic]

I don't think you're right that switch expects mutual exclusivity. With the already existing pattern matching, syntax like this is completely legal and works just fine:

int x = 100;
string result = x switch {
    > 50 => "number is very large",
    > 25 => "number is almost large",
    _ => "the number isn't large at all"
};

and exactly as HaloFour pointed out, the switch expression simply chooses the first "branch" that matches, which in this case is the first one. So although the "has" keyword might have some readability issues, it certainly isn't conceptually wrong.

[franchyd]

I don't think you're right that switch expects mutual exclusivity. With the already existing pattern matching, syntax like this is completely legal and works just fine:

int x = 100;
string result = x switch {
    > 50 => "number is very large",
    > 25 => "number is almost large",
    _ => "the number isn't large at all"
};

and exactly as HaloFour pointed out, the switch expression simply chooses the first "branch" that matches, which in this case is the first one. So although the "has" keyword might have some readability issues, it certainly isn't conceptually wrong.

I think my wording was poor, I was not meaning to say switches require mutually exclusive options, but moreover that they implicitly enforce them. Your example logically becomes:

int x = 100;
string result = x switch {
    > 50 => "number is very large",
    > 25 and<= 50 => "number is almost large",
    _ => "the number isn't large at all"
};

(logically but obviously not in bytecode)
I was arguing that the implicit logic transformation is a lot less transparent in enum flags than it is in numeric use-case to see that a case has been handled by previous cases. Honestly even the numeric cases can get lost if you have a large enough switch statement, but I'd expect that to be less common.
And yes this is a problem that already exists when using the existing verbose "when x.HasFlag" but not enshrined into its own feature.

[RikkiGibson]

I think the situation is somewhat improved by extension properties:

MyDaysOfWeek days = MyDaysOfWeek.Monday;
if (days is { HasMonday: true, HasTuesday: false, HasWednesday: true })
{
    // handling for Monday + Wednesday schedules
}

[Flags]
public enum MyDaysOfWeek
{
    Monday = 1 << 0,
    Tuesday = 1 << 1,
    Wednesday = 1 << 2,
    Thursday = 1 << 3,
    Friday = 1 << 4,
    Saturday = 1 << 5,
    Sunday = 1 << 6
}

public static class MyDaysOfWeekExtensions
{
    extension(MyDaysOfWeek value)
    {
        public bool HasMonday => (value & MyDaysOfWeek.Monday) == MyDaysOfWeek.Monday;
        public bool HasTuesday => (value & MyDaysOfWeek.Tuesday) == MyDaysOfWeek.Tuesday;
        public bool HasWednesday => (value & MyDaysOfWeek.Wednesday) == MyDaysOfWeek.Wednesday;
        // ...
    }
}