Default property for reading and setting bit flags

[AnthonyDGreen]

Bit twiddling to check and set flags is arcane. Given a flag enumeration of the form:

<Flags>
Enum Color
    Red = 1
    Green = 2
    Blue = 4
End Enum

To check whether a flag (or set of flags) is set you AND the bit mask with the value and compare it to itself:

Dim isRed = ((value And Color.Red) = Color.Red)
Dim isYellow = (value And (Color.Red Or Color.Green)) = (Color.Red Or Color.Green))

To set a flag on you OR the value with the mask:

value = (value Or Color.Red)

To set it to off you AND it with the negation of the flag (I think):

value = (value And Not Color.Red)

It also has this unfortunate side-effect that to see if both Red and Green are set you have to Or them. None of this is intuitive, fun, or memorable, and it lacks VB's brand of straightforward approachability. I propose that instead of forcing VB users to remember this low-level operations, adding an implicit default property to all the integral numeric types and any <Flags> enumerated types which takes a mask and returns true if the specified bits are on and false if they aren't and which lets you set the bits in the supplied mask to on or off.

To check whether a flag (or set of flags) is set you just index the value with the flag:

' Explicitly comparing to True for clarity
If value(Color.Red) = True Then
    ' Red.
End If

To set a flag on you set "the bit(s)" at that mask to true:

value(Color.Red) = True

To set it to off you set the bits at that mask to false:

value(Color.Red) = False

And the neat thing is that it's concise enough that if you want to check for more than one flag you can And the individual checks instead of Oring the values:

If value(Color.Red) = True AndAlso value(Color.Green) = True Then
    ' Yellow.
ElseIf value(Color.Red) = True OrElse value(Color.Green) = True Then
    ' I don't know why one would check this.
End If

That's much better, I think. I don't have to remember anything. The System.Enum.HasFlags method was added in .NET 4.0 to make this simpler but it uses reflection, is comparatively slow, and isn't strongly-typed. One could write extension methods but you'd need to do this on a per-type basis. BitVector32 is compact and speedy but not strongly-typed and limited to 32-bit integer stores. BitArray has a variable capacity but allocates a lot. With this we can keep the size and performance characteristics of using the integral types directly with strong typing and the compiler can optimize the Or and And cases for constants so that it has the same performance as the code you would write today.

Breaking Change
This could technically be a very minor breaking change because VB today lets you define an "extension readonly default property" on any type by defining an ElementAtOrDefault extension function and a Select extension method to make it a queryable type. There is no way to emulate the case of making the default property writeable.

This entire scenario seems extremely unlikely but the breaking change could be avoided entirely by binding this way only after the queryable/ElementAtOrDefault check fails.

[AdamSpeight2008]

We could incorporate this feature into the abilities of In (#160)

If (Color.Red Is In value) AndAlso (Color.Blue Is In value) Then

Wouldn't be a breaking change.

[gilfusion]

Is it me, or does reading bit flags sound like a job for pattern matching (#124)?

[AnthonyDGreen]

Pattern matching and In only reduce the complexity of checking for flags and would require adding another feature to address the (Imo greater) complexity of toggling bits. This takes an existing concept, default properties, and just applies it to another situation.

I updated the proposal with a note on how to avoid the break entirely.

[AdamSpeight2008]

@AnthonyDGreen
Setting on and off can currently be achieved with the operators + and - and respectively.
(run able source)

Imports System
Public Class C
    <Flags()>
    Enum Color As Integer
        None = 0
        Red  = 1
        Blue = 2
        Green = 4
    End Enum

    Public Shared Sub Main()
        Dim c As Color=Color.None
        c +=Color.Blue + Color.Red + Color.Green -Color.Blue
        Console.WriteLine($"{c}")
    End Sub
End Class

[AnthonyDGreen]

Only if those values aren't already set. It's not idempotent and is error prone if you don't do it just right.

This is a good idea, but it can be better like this:

value.Set(Color.Red, Color.Blue)
value.Reset(Color.Red, Color.Blue)
If Value.Get(Color.Blue) Then

This is a bit longer, but with a less confusion, and the ability to set as many flags as you desire in one call. The method Set can have a parameter array. Value.Set() means set them all
Aslo, It will nice to add

If Value.AllSet(Color.Blue, Color.Green) Then
If Value.AnySet(Color.Blue, Color.Green) Then

Also I suggest the compiler adds a new synatax like this:

Value.Red = False
Value.Blue = True
If Value.Red AndAlso Value.Blue Then

Which uses the above methods. The .Flag syntax is less confusing and more copact than the (Flag) syntax.
Thanks

So, why not to intoduce a new Type that inherits the enum class:

Flag Color
   Red
   Green
   Blue
End Flag

Dim value As Color
value.Red = True
if value.green then

you can't write:
value = color.green

This seems like a class with three boolean fileds, but the "value' variable can be converted to numeric value, and to enums marked as flags. This can be a feature of VB only, or can be done at the CLR level.

[AdamSpeight2008]

@AnthonyDGreen It is a shame that we can't constrain (Of T As {<Flags>Enum}) ,then the following extension methods would work rather nicely.

Public Module EnumExts

    <Runtime.CompilerServices.Extension()>
    Function IsSet(Of T As {<Flags>Enum})(x As T,y As T) As Boolean
        Return (x And y) = y
    End Function

    <Runtime.CompilerServices.Extension()>
    Function IsClear(Of T As {<Flags>Enum})(x As T,y As T) As Boolean
        Return (x And y) <> y
    End Function
    <Runtime.CompilerServices.Extension()>
    Function [Set](Of T As {<Flags>Enum})(x As T,y As T) As T
            Return x Or y
    End Function

    <Runtime.CompilerServices.Extension()>
    Function Clear(Of T As {<Flags>Enum})(x As T,y As T) As T
        Return x And Not y
    End Function    

End Module

eg

Dim state = Color.None
state = state.Set(Color.Red).Set(ColorBlue).Clear(Color.Red)
If state.IsSet(Color.Green) Then
 ... 

[AdamSpeight2008]

@AnthonyDGreen What about using the dictionary lookup operator?

Dim state = Color.None
state!Color.Red = True
state!Color.Blue = False
If state!Colour.Red Then

[rskar-git]

@AdamSpeight2008 I really like the dictionary lookup operator a whole lot better. Actually, wouldn't state!Red be better than state!Color.Red? I.e. state.Red is the constant (as it already is), but state!Red is the (Boolean) property.

@MohammadHamdyGhanem The Value.Red = False idea is nice, but would be a breaking change (right now it's the constant). But this notion and AdamSpeight2008's idea to use dictionary lookup operator I think is winning combination: Value!Red = False.

@AnthonyDGreen When I first saw the syntax proposed for this (of <Flag>enum(mask), e.g. value(Color.Red)) I wasn't too excited about it, but I sat back to see how others felt. In regards to a syntax of the form integerType(index), I would have liked it better to instead have it be a way to specify a bit; i.e. treat an integral type as if it were a packed array of bit, where index is 0 to Most-Significant-Bit (such as 31 or 15 or 63). So while I like #228 overall, I think a syntax drawing from AdamSpeight2008 and MohammadHamdyGhanem ideas would work great:

' Explicitly comparing to True for clarity
If value!Red = True Then
    ' Red.
End If

value!Red = True
value!Red = False

If value!Red = True AndAlso value!Green = True Then
    ' Yellow.
ElseIf value!Red = True OrElse value!Green = True Then
    ' I don't know why one would check this.
End If

[AdamSpeight2008]

@AnthonyDGreen

Rough addition to the specification to allow Enum Bit Operator

DictionaryAccessExpession ::= (Expr : Expression?) '!' (Key : IdentifierOrKeyword);

• If Expr evaluates to an Enum
  • True: If Expr has the <Flags> attribute.
    • True: Then parse Key as a member of that enumeration. eg Red, Blue, Green.
      • If Key is valid member then
        • If the Key is the default value (None in our example) mark the key as a warning.
          As usage should result in the value not being changed.
        • Otherwise this is valid representation
      • Otherwise Mark the key as an error Not a member of enumeration
    • False: Mark expr as an error. Enum doesn't have the attribute <Flags>
  • False Continue as a normal dictionary lookup expression.