''示例类型
Type T
  ''值由构造函数设置
  value As Double
  Declare Constructor( ByVal x As Double = 0 )

  Declare Operator For( ByRef stp As T )
  Declare Operator Step( ByRef stp As T )
  Declare Operator Next( ByRef cond As T, ByRef stp As T ) As Integer
End Type

Constructor T ( ByVal x As Double )
  Print "T值迭代器" & x
  value = x
End Constructor

Operator T.for( ByRef stp As T )
End Operator

Operator T.step( ByRef stp As T )
  Print "递增" & stp.value & "在步骤"
  value += stp.value
End Operator

Operator T.next( ByRef cond As T, ByRef stp As T ) As Integer
  '' iterator's从高值移动到低值（步骤>= 0）
  If( stp.value < 0 ) Then
    Return( value >= cond.value )
  Else
  '' iterator's从低值移动到高值（步骤<0）
    Return( value <= cond.value )
  End If
End Operator

''使用示例看起来我们正在使用数字，但迭代器
''有重载的构造函数。10，1和-1都是T型。
For i As T = 10 To 1 Step -1
  Print i.value;
Next i

''一个遍历文件的类
Type FileIter
    As String pathName, fileName
    Declare Constructor( ByRef pathName As String )

    Declare Operator For()
    Declare Operator Step()
    Declare Operator Next( ByRef endCond As FileIter) As Integer
End Type

Constructor FileIter( ByRef pathName As String )   
    this.pathName = pathName
End Constructor

Operator FileIter.for( )   
    fileName = Dir(pathName & "/*.*")   
End Operator

Operator FileIter.step( )   
    fileName = Dir("")
End Operator

Operator FileIter.next( ByRef endCond As FileIter ) As Integer
    Return(fileName <> endCond.pathName)   
    '' the c'tor设置路径名称，所以我们检查
End Operator

''示例代码
''将其更改为任何目录
For i As FileIter = "./" To ""
    Print i.fileName
Next

Type CharIterator
    ''用来构建一个步骤var
    Declare Constructor( ByVal r As ZString Ptr )
    
    ''隐式步骤版本
    Declare Operator For ( )
    Declare Operator Step( )
    Declare Operator Next( ByRef end_cond As CharIterator ) As Integer
    
    ''明确的步骤版本
    Declare Operator For ( ByRef step_var As CharIterator )
    Declare Operator Step( ByRef step_var As CharIterator )
    Declare Operator Next( ByRef end_cond As CharIterator, ByRef step_var As CharIterator ) As Integer
    
    ''给出当前的“价值”
    Declare Operator Cast( ) As String
    
    Private:    
        ''数据
        value As String
        
        '' This member isn'必要 - 我们可以使用
        ''每个迭代的步变量 -
        ''但我们选择这种方法，因为我们有
        ''比较字符串。见下文。
        is_up As Integer
End Type

Constructor CharIterator( ByVal r As ZString Ptr )
    value = *r
End Constructor

Operator CharIterator.cast( ) As String
    Operator = value
End Operator

''隐式步骤版本
''
''在这个例子中，我们解释隐含的步骤
'' to always mean 'up'
Operator CharIterator.for( )
    Print "隐含的步骤"
End Operator

Operator CharIterator.step( )
    value[0] += 1
End Operator 

Operator CharIterator.next( ByRef end_cond As CharIterator ) As Integer
    Return this.value <= end_cond.value
End Operator

''明确的步骤版本
''
''在这个例子中，我们计算方向
''在FOR中，但是由于步骤var被传递到
''每个操作符，我们有选择也可以计算
''它“即时”。对于这样的字符串，反复比较
'' may penalize, but if you'重新使用更简单的类型，
''那么你可能更喜欢避免开销
'' an 'is_up'变量。
Operator CharIterator.for( ByRef step_var As CharIterator )
    Print "明确的步骤"
    is_up = (step_var.value = "up")
End Operator

Operator CharIterator.step( ByRef step_var As CharIterator )
    If( is_up ) Then
        value[0] += 1
    Else
        value[0] -= 1
    End If
End Operator 

Operator CharIterator.next( ByRef end_cond As CharIterator, ByRef step_var As CharIterator ) As Integer
    If( this.is_up ) Then
        Return this.value <= end_cond.value
    Else
        Return this.value >= end_cond.value
    End If
End Operator

For i As CharIterator = "a" To "z"
    Print i; "";
Next
Print "DONE"

For i As CharIterator = "a" To "z" Step "up"
    Print i; "";
Next
Print "DONE"

For i As CharIterator = "z" To "a" Step "下"
    Print i; "";
Next
Print "DONE"

For i As CharIterator = "z" To "a" Step "up"
    Print i; "";
Next
Print "DONE"

Type fraction
    ''用于构建一个步骤var
    Declare Constructor( ByVal n As Integer, ByVal d As Integer )

    ''隐式步骤版本
    Declare Operator For ( )
    Declare Operator Step( )
    Declare Operator Next( ByRef end_cond As fraction ) As Integer

    ''显式步骤版本
    Declare Operator For ( ByRef step_var As fraction )
    Declare Operator Step( ByRef step_var As fraction )
    Declare Operator Next( ByRef end_cond As fraction, ByRef step_var As fraction ) As Integer

    ''给出当前的“价值”
    Declare Operator Cast( ) As Double
    Declare Operator Cast( ) As String

    Private:
        As Integer num, den
End Type

Constructor fraction( ByVal n As Integer, ByVal d As Integer )
    this.num = n : this.den = d
End Constructor

Operator fraction.cast( ) As Double
    Operator = num / den
End Operator

Operator fraction.cast( ) As String
    Operator = num & "/" & den
End Operator

''一些分数函数
Function gcd( ByVal n As Integer, ByVal m As Integer ) As Integer
    Dim As Integer t
        While m <> 0
            t = m
            m = n Mod m
            n = t
        Wend
    Return n
End Function

Function lcd( ByVal n As Integer, ByVal m As Integer ) As Integer
    Return (n * m) / gcd( n, m )
End Function

''
''隐式步骤版本
''
''在这个例子中，我们解释隐含的步骤
''意思是1
''
Operator fraction.for( )
    Print "隐含的步骤"
End Operator

Operator fraction.step( )
    Var lowest = lcd( this.den, 1 )

    Var mult_factor = this.den / lowest
    Dim As fraction step_temp = fraction( 1, 1 )
    
    this.num *= mult_factor
    this.den *= mult_factor
    
    step_temp.num *= lowest
    step_temp.den *= lowest
    
    this.num += step_temp.num
End Operator 

Operator fraction.next( ByRef end_cond As fraction ) As Integer
    Return This <= end_cond
End Operator

''
''显式步骤版本
''
Operator fraction.for( ByRef step_var As fraction )
    Print "明确的步骤"
End Operator

Operator fraction.step( ByRef step_var As fraction )
    Var lowest = lcd( this.den, step_var.den )
    Var mult_factor = this.den / lowest
    Dim As fraction step_temp = step_var

    this.num *= mult_factor
    this.den *= mult_factor

    mult_factor = step_temp.den / lowest

    step_temp.num *= mult_factor
    step_temp.den *= mult_factor

    this.num += step_temp.num
End Operator 

Operator fraction.next( ByRef end_cond As fraction, ByRef step_var As fraction ) As Integer
    If(( step_var.num < 0 ) Or ( step_var.den < 0 ) ) Then
        Return This >= end_cond
    Else
        Return This <= end_cond
    End If
End Operator

For i As fraction = fraction(1,1) To fraction(4,1)
    Print i; "";
Next
Print "DONE"

For i As fraction = fraction(1,4) To fraction(1,1) Step fraction(1,4)
    Print i; "";
Next
Print "DONE"

For i As fraction = fraction(4,4) To fraction(1,4) Step fraction(-1,4)
    Print i; "";
Next
Print "DONE"

For i As fraction = fraction(4,4) To fraction(1,4)
    Print i; "";
Next
Print "DONE"