anchor.diff:              // transition edges to it from the initial state.
               if CharSet.isEmpty wildcardChars then
                   // TODO : Emit a warning to let the user know this pattern will never be matched.
  -                Debug.WriteLine "Warning: Wildcard pattern in rule will never be matched."
  +                Printf.dprintfn "Warning: Wildcard pattern in rule will never be matched."
   
                   compiledPatternDfa
               else
  
positive.code: 
  /// Creates pattern-matching DFAs from the lexer rules.
  let lexerSpec (spec : Specification) options =
      // Validate and simplify the macros to create the macro table/environment.
      match preprocessMacros spec.Macros options with
      | Choice2Of2 (macroEnv, badMacros, errors) ->
          // TODO : Validate the rule clauses, but don't compile the rule DFAs.
          // This way we can return all applicable errors instead of just those for the macros.
          Choice2Of2 errors
      | Choice1Of2 macroEnv ->
          (* Compile the lexer rules *)
          (* TODO :   Simplify the code below using monadic operators. *)
          let ruleIdentifiers, rules =
              let ruleCount = List.length spec.Rules
              let ruleIdentifiers = Array.zeroCreate ruleCount
              let rules = Array.zeroCreate ruleCount
  
              // TODO : Check for duplicate rule identifiers
              (ruleCount - 1, spec.Rules)
              ||> List.fold (fun index (ruleId, rule) ->
                  ruleIdentifiers.[index] <- ruleId
                  rules.[index] <- rule
                  index - 1)
              |> ignore
  
              ruleIdentifiers, rules
  
          let compiledRules, compilationErrors =
              rules
              |> Array.mapPartition (fun rule ->
                  compileRule rule options (macroEnv, Set.empty))
  
          // If there are errors, return them; otherwise, create a
          // CompiledSpecification record from the compiled rules.
          if Array.isEmpty compilationErrors then
              Choice1Of2 {
                  Header = spec.Header;
                  Footer = spec.Footer;
                  CompiledRules =
                      (Map.empty, ruleIdentifiers, compiledRules)
                      |||> Array.fold2 (fun map (_, ruleId) compiledRule ->
                          Map.add ruleId compiledRule map); }
          else
              Choice2Of2 <| Array.concat compilationErrors
  
  
negative.code:     choice {
      // Validate and simplify the patterns of the rule clauses.
      let! ruleClauseRegexes =
          // Put all of the "results" in one array and all of the "errors" in another.
          let results, errors =
              patterns
              |> Array.mapPartition (fun (originalRuleClauseIndex, pattern) ->
                  validateAndSimplifyPattern pattern (macroEnv, badMacros, options)
                  |> Choice.map (fun pattern ->
                      originalRuleClauseIndex, pattern))
  
          // If there are any errors return them; otherwise, return the results.
          if Array.isEmpty errors then
              Choice1Of2 results
          else
              // Flatten the error array.
              Choice2Of2 <| Array.concat errors
  
      /// The DFA compiled from the rule clause patterns.
      let compiledPatternDfa =
  