anchor.diff:          createDfa initialPending compilationState
   
       //
  -    let clausesAcceptedByDfaState =
  -        (Map.empty, compilationState.FinalStates)
  -        ||> Set.fold (fun map finalDfaStateId ->
  -            let acceptedRules : Set<RuleClauseIndex> =
  -                // Get the regular vector represented by this DFA state.
  -                compilationState.DfaStateToRegularVector
  -                |> Map.find finalDfaStateId
  -                // Determine which lexer rules are accepted by this regular vector.
  -                |> RegularVector.acceptingElements
  -                // Map the indices of the patterns in the regular vector back to their
  -                // original RuleClauseIndex (it can be different if there are EOF-accepting
  -                // clauses defined within the same rule).
  -                |> Set.map (Array.get patternIndices)
  -                
  -            Map.add finalDfaStateId acceptedRules map)
  +    let clausesAcceptedByDfaState : Map<_, Set<RuleClauseIndex>> =
  +        compilationState.FinalStates
  +        |> Map.ofKeys (fun finalDfaStateId ->
  +            // Get the regular vector represented by this DFA state.
  +            compilationState.DfaStateToRegularVector
  +            |> Map.find finalDfaStateId
  +            // Determine which lexer rules are accepted by this regular vector.
  +            |> RegularVector.acceptingElements
  +            // Map the indices of the patterns in the regular vector back to their
  +            // original RuleClauseIndex (it can be different if there are EOF-accepting
  +            // clauses defined within the same rule).
  +            |> Set.map (Array.get patternIndices))
   
       (* TODO :   Add code here to generate warnings about overlapping rules. *)
   
  
positive.code:             ruleIdentifiers, rules
  
          let compiledRules, compilationErrors =
              let compiledRulesOrErrors =
                  rules
                  |> Array.map (fun rule ->
                      compileRule rule options (macroEnv, Set.empty))
  
              let compiledRules = ResizeArray<_> (Array.length rules)
              let compilationErrors = ResizeArray<_> (Array.length rules)
  
              compiledRulesOrErrors
              |> Array.iter (function
                  | Choice1Of2 compiledRule ->
                      compiledRules.Add compiledRule
                  | Choice2Of2 errors ->
                      compilationErrors.AddRange errors)
  
              compiledRules.ToArray (),
              compilationErrors.ToArray ()
  
          // If there are errors, return them; otherwise, create a
          // CompiledSpecification record from the compiled rules.
  
negative.code:     //
      // OPTIMIZE : Modify this function to use a LazyList to hold the errors
      // instead of an F# list to avoid the list concatenation overhead.
      // OPTIMIZE : Simplify this function using the Cps.choice workflow from ExtCore.
      let rec validateAndSimplify pattern cont =
          match pattern with
          | Pattern.Epsilon ->
  