anchor.diff:                  ["Unicode category patterns may not be used unless the 'Unicode' compiler option is set."]
                   |> Choice2Of2
                   |> cont
  +
  +        (* Wildcard pattern *)
  +        | Pattern.Any ->
  +            // Macros are not allowed to use the wildcard pattern.
  +            ["The wildcard pattern cannot be used within macro definitions."]
  +            |> Choice2Of2
  +            |> cont
   
       /// Contains an error if a macro has already been defined with this name; otherwise, None.
       let duplicateNameError =
  
positive.code:         // create an additional DFA state to serve as the EOF-accepting state
          // and create a transition edge labeled with the EOF symbol to it.
          let compiledPatternDfa =
              match eofAcceptingClause with
              | None -> compiledPatternDfa
              | Some eofAcceptingClause ->
                  let dfaAcceptingState, transitions =
                      LexerDfaGraph.createVertex compiledPatternDfa.Transitions
                  let transitions =
                      LexerDfaGraph.addEofEdge compiledPatternDfa.InitialState dfaAcceptingState transitions
                  { compiledPatternDfa with
                      Transitions = transitions;
                      RuleAcceptedByState =
                          compiledPatternDfa.RuleAcceptedByState
                          |> Map.add dfaAcceptingState eofAcceptingClause; }
  
          // If this rule has a clause with the wildcard pattern, create an additional
          // DFA state which accepts any single character which won't be matched by the
          // earlier patterns in the rule.
          let compiledPatternDfa =
              match wildcardClauseIndex with
              | None ->
                  compiledPatternDfa
              | Some wildcardClauseIndex ->
                  // TEMP : The way the transition characters are computed here is specific
                  // to fslex -- once we implement our own interpreter, we'll have to come
                  // up with a backend-specific way to handle this. Perhaps we can just store
                  // the wildcard-clause index in the returned DFA, and let the plugins themselves
                  // compute the transition characters.
  
                  //
                  
  
  
  
  
  
                  raise <| System.NotImplementedException "wildcardClauseIndex"
  
          // TODO : Emit warnings about any overlapping patterns.
          // E.g., "This pattern will never be matched."
  
negative.code:             Some acceptingClauseIndex
  
      /// The index of the wildcard rule clause, if this rule contains one.
      let wildcardAcceptingClauseIndex =
          let wildcardClauseIndices =
              patterns
              |> Array.choose (fun (idx, pat) ->
  