anchor.diff:                  str <- str + "; ..."
               str + "]"
   
  -    type FromFunctions<'T>(get, next, dispose) =
  +    type FromFunctions<'T>(current, next, dispose) =
           interface IEnumerator<'T> with
  -            member __.Current = get()
  +            member __.Current = current()
           interface System.Collections.IEnumerator with
  -            member __.Current = box (get())
  +            member __.Current = box (current())
               member __.MoveNext() = next()
               member __.Reset() = noReset()
           interface System.IDisposable with
               member __.Dispose() = dispose()
   
  -    let inline fromFunctions get next dispose: IEnumerator<'T> =
  -        new FromFunctions<_>(get, next, dispose) :> IEnumerator<'T>
  +    let inline fromFunctions current next dispose: IEnumerator<'T> =
  +        new FromFunctions<_>(current, next, dispose) :> IEnumerator<'T>
   
       // // implementation for languages where arrays are not IEnumerable
  +    //
  +    // let empty<'T>(): IEnumerator<'T> =
  +    //     let mutable started = false
  +    //     let current() = if not started then notStarted() else alreadyFinished()
  +    //     let next() = started <- true; false
  +    //     let dispose() = ()
  +    //     fromFunctions current next dispose
  +    //
  +    // let singleton (x: 'T): IEnumerator<'T> =
  +    //     let mutable index = -1
  +    //     let current() =
  +    //         if index < 0 then notStarted()
  +    //         if index > 0 then alreadyFinished()
  +    //         x
  +    //     let next() = index <- index + 1; index = 0
  +    //     let dispose() = ()
  +    //     fromFunctions current next dispose
       //
       // let ofArray (arr: 'T[]): IEnumerator<'T> =
       //     let len = arr.Length
       //     let mutable i = -1
  -    //     let get() =
  +    //     let current() =
       //         if i < 0 then notStarted()
       //         elif i >= len then alreadyFinished()
       //         else arr.[i]
  
positive.code:     //             i < len
      //         else false
      //     let dispose() = ()
      //     fromFunctions get next dispose
      //
      // let empty<'T>(): IEnumerator<'T> =
      //     let mutable started = false
      //     let get() = if not started then notStarted() else alreadyFinished()
      //     let next() = started <- true; false
      //     let dispose() = ()
      //     fromFunctions get next dispose
      //
      // let singleton (x: 'T): IEnumerator<'T> =
      //     let mutable index = -1
      //     let get() =
      //         if index < 0 then notStarted()
      //         if index > 0 then alreadyFinished()
      //         x
      //     let next() = index <- index + 1; index = 0
      //     let dispose() = ()
      //     fromFunctions get next dispose
  
      let cast (e: System.Collections.IEnumerator): IEnumerator<'T> =
          let get() = unbox<'T> e.Current
          let next() = e.MoveNext()
          let dispose() =
              match e with
              | :? System.IDisposable as e -> e.Dispose()
              | _ -> ()
          fromFunctions get next dispose
  
      let concat<'T,'U when 'U :> seq<'T>> (sources: seq<'U>) =
          let mutable outerOpt: IEnumerator<'U> option = None
  
negative.code:             if finished then false
              else loop ()
          let dispose() = if not finished then finish()
          fromFunctions current next dispose
  
      let enumerateThenFinally f (e: IEnumerator<'T>): IEnumerator<'T> =
          let current() = e.Current
          let next() = e.MoveNext()
          let dispose() = try e.Dispose() finally f()
          fromFunctions current next dispose
  
      let generateWhileSome (openf: unit -> 'T) (compute: 'T -> 'U option) (closef: 'T -> unit): IEnumerator<'U> =
          let mutable started = false
          let mutable curr = None
          let mutable state = Some (openf())
          let current() =
              if not started then notStarted()
              match curr with
              | None -> alreadyFinished()
  