anchor.diff:                  str <- str + "; ..."
               str + "]"
   
  -    // // in JS using this object is slower than the object expression below
  -    //
  -    // type FromFunctions<'T>(get, next, reset, dispose) =
  -    //     interface IEnumerator<'T> with
  -    //         member __.Current = get()
  -    //     interface System.Collections.IEnumerator with
  -    //         member __.Current = box (get())
  -    //         member __.MoveNext() = next()
  -    //         member __.Reset() = reset()
  -    //     interface System.IDisposable with
  -    //         member __.Dispose() = dispose()
  -
  -    // let inline fromFunctions get next reset dispose: IEnumerator<'T> =
  -    //     new FromFunctions<_>(get, next, reset, dispose) :> IEnumerator<'T>
  -
  -    let fromFunctions get next reset dispose: IEnumerator<'T> =
  -        { new IEnumerator<'T> with
  -                member __.Current = get()
  -            interface System.Collections.IEnumerator with
  -                member __.Current = box (get())
  -                member __.MoveNext() = next()
  -                member __.Reset() = reset()
  -            interface System.IDisposable with
  -                member __.Dispose() = dispose() }
  +    type FromFunctions<'T>(get, next, dispose) =
  +        interface IEnumerator<'T> with
  +            member __.Current = get()
  +        interface System.Collections.IEnumerator with
  +            member __.Current = box (get())
  +            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>
   
       // // implementation for languages where arrays are not IEnumerable
       //
  
positive.code:     | :? array<'T> as a -> List.ofArray a
      | :? list<'T> as a -> a
      | _ -> List.ofSeq xs
  
  let empty () =
      delay (fun () -> Array.empty :> seq<'T>) // Enumerator.empty<_>())
  
  let singleton x =
      delay (fun () -> (Array.singleton x) :> seq<'T>) // Enumerator.singleton x)
  
  let generate create compute dispose =
      mkSeq (fun () -> Enumerator.generateWhileSome create compute dispose)
  
negative.code:                 match (try compute s with _ -> finish(); reraise()) with
                  | None -> finish(); false
                  | Some _ as x -> curr <- x; true
          fromFunctions get next dispose
  
      let unfold (f: 'State -> ('T * 'State) option) (state: 'State): IEnumerator<'T> =
          let mutable curr: ('T * 'State) option = None
  