anchor.diff:  type LexerRuleDfa = {
       /// The transition graph of the DFA.
       Transitions : LexerDfaGraph;
  -    //
  -    RuleClauseFinalStates : Set<DfaStateId>[];
       /// For each accepting state of the DFA, specifies the
       /// index of the rule-clause accepted by the state.
       RuleAcceptedByState : Map<DfaStateId, RuleClauseIndex>;
  
positive.code:         // lowest index -- i.e., the rule which was declared earliest in the lexer definition.
          |> Map.map (fun _ -> Set.minElement)
  
      // TODO : Is this code still needed? If not, discard it.
      let ruleAcceptingStates =
          let ruleAcceptingStates = Array.create (Array.length rulePatterns) Set.empty
  
          rulesAcceptedByDfaState
          |> Map.iter (fun finalDfaStateId acceptedRules ->
              Debug.Assert (
                  not <| Set.isEmpty acceptedRules,
                  sprintf "DFA state '%i' is marked as a final state but does not accept any rules." (int finalDfaStateId))
  
              acceptedRules
              |> Set.iter (fun acceptedRuleIndex ->
                  ruleAcceptingStates.[int acceptedRuleIndex] <-
                      ruleAcceptingStates.[int acceptedRuleIndex]
                      |> Set.add finalDfaStateId))
  
          ruleAcceptingStates
  
      // Create a LexerDfa record from the compiled DFA.
      {   Transitions = compilationState.Transitions;
          RuleClauseFinalStates = ruleAcceptingStates;
          RuleAcceptedByState = ruleAcceptedByDfaState;
          InitialState = initialDfaStateId; }
  
  
negative.code:                     LexerDfaGraph.addEofEdge compiledPatternDfa.InitialState dfaAcceptingState transitions
                  { compiledPatternDfa with
                      Transitions = transitions;
                      RuleAcceptedByState =
                          compiledPatternDfa.RuleAcceptedByState
                          |> Map.add dfaAcceptingState eofAcceptingClause; }
  