anchor.diff:  /// </remarks>
   let tokenize (dfa : Dfa<'Symbol>) (symbols : seq<'Symbol>) : seq<Choice<int<RegexIndex> * 'Symbol[], 'Symbol[]>> =
       //
  -    let rec tokenize (symbolEnumerator : IEnumerator<'Symbol>) tokenizerState = seq {
  +    let rec tokenize (symbolEnumerator : System.Collections.Generic.IEnumerator<'Symbol>) tokenizerState = seq {
           // Try to read a symbol from the stream or pending characters queue.
           let symbol, tokenizerState =
               // If the buffer contains any symbols, return the next symbol in
  
positive.code:                 |> Option.bind (Map.tryFind symbol)
  
              match transitionTarget with
              | None ->
                  // Add this symbol to the buffer so it will be reprocessed.
                  let tokenizerState =
                      { tokenizerState with
                          Buffer = Queue.enqueue symbol tokenizerState.Buffer; }
  
                  // If the current DFA state is a final (accepting) state,
                  // accept the current token.
                  match Map.tryFind tokenizerState.CurrentState dfa.FinalStates with
                  | Some regexIndex ->
                      let (), tokenizerState = TokenizerState.checkpoint tokenizerState
                      let token, tokenizerState = TokenizerState.accept tokenizerState
  
                      // Emit the accepted token.
  
negative.code:                 // avoid creating the intermediate array.
                  (tokenizerState.Accepted, Queue.toArray tokenizerState.Pending)
                  ||> Array.fold (fun accepted el -> el :: accepted);
              Pending = Queue.empty; }
  
      //
      let checkpoint (tokenizerState : TokenizerState<'Symbol>) =
          let (), tokenizerState = markFinalState tokenizerState
          acceptPending tokenizerState
  
      /// Gets the current token ('Symbol[]) and clears the list of
      /// accepted symbols from the tokenizer state.
  