anchor.diff:                      yield token
   
                       // Move the pending symbols into the buffer.
  +                    // They are placed at the front of the buffer to keep
  +                    // the symbols in the same order as they were in the symbol stream.
                       let tokenizerState =
                           { tokenizerState with
                               Pending = Queue.empty;
  -                            Buffer =
  -                                // OPTIMIZE : This should be implemented more efficiently,
  -                                // perhaps as a Queue.toList function.
  -                                List.ofArray <| Queue.toArray tokenizerState.Pending; }
  +                            Buffer = 
  +                                // OPTIMIZE : Implement a Queue.fold function for this.
  +                                let pending = Queue.toArray tokenizerState.Pending
  +                                (tokenizerState.Buffer, pending)
  +                                ||> Array.fold (fun buffer el ->
  +                                    Queue.enqueue el buffer); }
                       
                       // Start tokenizing again at the initial DFA state.
                       let (), tokenizerState = TokenizerState.transition dfa.InitialState tokenizerState
  
positive.code: 
              match transitionTarget with
              | None ->
                  // If the current DFA state is a final (accepting) state,
                  // accept the current token.
                  match Map.tryFind tokenizerState.CurrentState dfa.FinalStates with
  
negative.code:                     yield! tokenize symbolEnumerator tokenizerState
  
          | Some symbol ->
              // Determine if there is a transition out of the current state
              // which is labeled with this symbol.
              let transitionTarget =
  