rskar-git
commented
5 years ago Putting constraints directly on a field or automatic variable probably wouldn't work out on the compiler side. The problem is in how to make sure the constraints get applied reliably, especially in calls to other DLL's. The other issue is one of maintenance; ad-hoc constraints would encourage "magic number" anti-patterns too easily.
Instead, what is generally done is one creates a new data type - a "subtype". Specifically, a subtype scheme for Structure types (a.k.a. value types in .NET). E.g., in Ada
subtype Int is Integer;
subtype Small_Int is Integer range -10 .. 10;In Ada, such constraints via subtypes are guaranteed to get strictly enforced.
So what I would be happy to see is maybe some sort of subtype system. But it's unclear to me how this might look in VB. Maybe the Narrowing keyword could be used in conjunction with Structure?
Enum Fruit As Integer
Apple = 10
Banana = 22
Cherry = 300
Dates = 499
Elderberry = 543
Fig = 688
Grapes = 733
Honeydew = 877
Kiwi = 22
End Enum
Structure CulledFruit As Narrowing Fruit Is {Apple, Cherry}
Structure First3Fruits As Narrowing Fruit Is Apple To Cherry
Structure SmallFruits As Narrowing Fruit Is Cherry To Elderberry, {Grapes}
Structure FruitSalad As Narrowing Fruit Is Apple To Cherry, {Grapes, Elderberry, Honeydew}
Structure FavoritesInFruitSalad As Narrowing FruitSalad Is {Apple, Banana, Grapes}
Structure Tenish As Narrowing Integer Is -10 To 10
Structure OddsUpTo20 As Narrowing Double Is {3, 5, 7, 9, 11, 13, 15, 17, 19}So your example would look something like this:
Structure Valid_x As Narrowing Integer Is -10 To 10
Structure Valid_y As Narrowing Integer Is {1, 3, 7, 10}
Structure Valid_z As Narrowing Integer Is 20 To 40, {1, 3, 7, 10}
Dim x As Valid_x
Dim y As Valid_y
Dim z As Valid_z
x = 3 ' OK
y = 100 ' Exception
z = 5 ' ExceptionThis could be lowered to something resembling this:
<DebuggerDisplay("{[default].Value}")>
Structure Valid_z
' Presumably the lowered code could duplicate this "Implements"
Implements IComparable, IComparable(Of Valid_z), IConvertible, IEquatable(Of Valid_z), IFormattable
Public ReadOnly [default] As Int32?
Public Shared Function Contains(x As Int32) As Boolean
Return (x >= 20 AndAlso x <= 40) OrElse
{1, 3, 7, 10}.Contains(x)
End Function
Public Sub New(Value As Int32)
If Contains(Value) Then
Me.default = Value
Else
Throw New ArgumentException()
End If
End Sub
Private Sub New(Value As Int32, ValidFlag As Boolean)
If ValidFlag Then
Me.default = Value
Else
Throw New InvalidCastException()
End If
End Sub
Public Shared Narrowing Operator CType(x As Int32) As Valid_z
Return New Valid_z(x, Contains(x))
End Operator
Public Shared Widening Operator CType(x As Valid_z) As Int32
If x.default.HasValue Then Return CType(x.default, Int32)
Throw New InvalidCastException()
End Operator
' Presumably the lowered code could create various members as needed
' based on whatever is getting subtyped
Public Shared Function Parse(s As String) As Valid_z
' ...
End Function
Public Function Equals(obj As Valid_z) As Boolean
' ...
End Function
' etc. ...
End StructureNote the use of Nullable(Of T) (e.g. Int32?) - it would seem in .NET a value type must support being instantiated as all its bits are zeros. Hence the subtype must be nullable to detect this situation, since all zeros might not be valid.
VBAndCs
paul1956
rrvenki
This is a feature I am waiting for for years, even before ASP.NET MVC added some validation attributes to the Model members, and I am wondering why this didn't happen until now!
We can force variables to accept some values only like this:
This can be lowered to:
Where:
Note: If the x is set via a ByRef parameter, then the Assign_x should be called when setting that parameter inside the function.
The real benefit of this is to have an easy way to force some constrains over property values and function params:
In this case, VB can add the validation conditions for the param or the value in the beginning of the function or the Set block. The back field of the property should be validated also.