[VB LINQ] Range Query Syntax

[AdamSpeight2008]

Range Query Syntax

Dim odd = From x In 1 To 100 Step 2
Dim HundredToZero = From x In 100 To 0 Step -2

[HaloFour]

I assume that Step would be optional as it is with For loops:

Dim numbers = From x In 1 To 100

How about if you omit the To clause and only include the Step clause, could that create an unbounded enumerable?

Dim allEvens = From x In 2 Step 2

Even if not I'd say that this would fit well with VB syntax. My only question would be about the compiler being able to properly distinguish this feature from trying to find a GetEnumerator extension method defined on System.Int32.

That said, it'd also be very easily to emulate a language feature through extension methods:

Dim odd = From x In 1.To(100).Step(2)

[AdamSpeight2008]

@HaloFour The extension methods are ok, when then range is ascending. It when is descending it get complex,

Dim xs = From x In 99 To 0 Step -2
Dim a As UInt = CUInt( 99 )
Dim b As UInt = CUInt( 1 )
Dim ys = From x In a To b Step -1 '

edit

Module Module1

    Sub Main()
        Dim xs0 As IEnumerable(Of Integer) = (10).To(100).Step(10).ToArray
        Dim xs1 As IEnumerable(Of Integer) = (10).ToWithStep(100, 10).ToArray
        Dim ys0 As IEnumerable(Of Integer) = (99).To(1).Step(-2).ToArray
        Dim ys1 As IEnumerable(Of Integer) = (99).ToWithStep(1, -2).ToArray
        Debug.Assert(xs0.SequenceEqual(xs1))
        Debug.Assert(ys0.SequenceEqual(ys1))
    End Sub


    <Runtime.CompilerServices.Extension>
    Function [To](x As Integer, y As Integer) As IEnumerable(Of Integer)
        Dim _Descending_ = Iterator Function() As IEnumerable(Of Integer)
                               For i = x To y Step -1 : Yield i : Next
                           End Function
        Dim _Ascending_ = Iterator Function() As IEnumerable(Of Integer)
                              For i = x To y : Yield i : Next
                          End Function
        Return If(x <= y, _Ascending_, _Descending_)()
    End Function

    <Runtime.CompilerServices.Extension>
    Function [Step](xs As IEnumerable(Of Integer), s As Integer) As IEnumerable(Of Integer)
        Return xs.Where(Function(x, ix) ix Mod s = 0)
    End Function

    <Runtime.CompilerServices.Extension>
    Iterator Function ToWithStep(x As Integer, y As Integer, s As Integer) As IEnumerable(Of Integer)
        If x <= y Then
            If s <= 0 Then Throw New ArgumentOutOfRangeException(NameOf(s))
        Else
            If s >= 0 Then Throw New ArgumentOutOfRangeException(NameOf(s))
        End If
        For i = x To y Step s
            Yield i
        Next
    End Function
End Module

The compiler could make the code optmise towards the ToWithStep method, rather than two separate iterators.

[AdamSpeight2008]

Also why can't the compiler, compile this.

For i As UInteger = CUInt(100) To CUInt(0) Step -1 ' the -1 is a compile-time error.

As if it was doing

 ' Pseudo-syntax.
For  DirectCast( i , UInteger) As Integer = CInt( CUInt(100)) To CInt( CUInt(0) ) Step CInt(-1) .

[alrz]

This is similar to #7632 for C#. I would very appreciate it if there was also a pattern counterpart. which by the way, is available in VB already.

For index = 0 To array.Length
    ...
Next

Select Case number
    Case 1 To 5
        ...
End Select

foreach(var index in 0 .. array.Length) { }

switch(number) {
  case 1 .. 5: break;
}

The foreach could be translated to a for but unlike for would not reuse the iterator variable.

The range may be used as an standalone expression returning an IEnumerable.

[AdamSpeight2008]

@alrz
I hadn't consider the pattern form, but thinking about it would be useful.
Case 0 To 100 ' Range eg 0 <= value <= 100
Case 0 To 100 Step 2 ' Selection equivalent to Case 0, 2, 4 ... 96, 98, 100

Should the pieces of the pattern _a_ To _b_ Step _c_ have the same type?
typeof( _a_ ) == typeof( _b_ ) == tupeof( _c_ )
Should we restrict the feature to just the core types? If not how to determine what is a compile error.
Eg `Case "A"c To "Z" Step "A"c

Select Case obj
  Case 0 To 100 ' Range (eg 0 <= obj <= 100 )
  Case 0 To 100 Step 2 ' Selection eg ( 0, 2, 4, ... 96, 98, 100)
  Case #00:00:00# To #23;59:59# Step #00:30:00# ' Half hours.
  Case "A" To "Z" ' String
  Case "A" To "Z" Step "A" ' Error
  Case "A"c To "Z" ' Char
  Case "A"c To "Z"c ' Error
  Case 0.0 To 100.0 ' Double

[AdamSpeight2008]

Ported to VBLang