anchor.diff:          | Choice1Of2 processedPattern ->
               Choice1Of2 processedPattern
   
  -/// <summary>An <see cref="IMapReduction`2"/> which can be used to compute the alphabet of a regular vector.</summary>
  -/// <remarks>
  -/// This is only necessary for fslex compatibility; once fsharplex has it's own backend (e.g., direct-style),
  -/// this won't be needed anymore (though it may be retained as a library function for diagnostics purposes).
  -/// </remarks>
  -let private regexAlphabetMapReduce =
  -    /// Gets the alphabet of a regular expression.
  -    /// The alphabet is the set of symbols which may be matched at any state by the regular expression.
  -    let rec getAlphabet regex =
  -        cont {
  -        match regex with
  -        | Regex.Any
  -        | Regex.Epsilon ->
  -            return CharSet.empty
  -
  -        | Regex.CharacterSet charSet ->
  -            return charSet
  -
  -        | Regex.Negate r
  -        | Regex.Star r ->
  -            return! getAlphabet r
  -
  -        | Regex.And (r, s)
  -        | Regex.Concat (r, s)
  -        | Regex.Or (r, s) ->
  -            let! rAlphabet = getAlphabet r
  -            let! sAlphabet = getAlphabet s
  -            return CharSet.union rAlphabet sAlphabet
  -        }
  -
  -    { new IMapReduction<_,_> with
  -        member __.Map (regex : Regex) =
  -            getAlphabet regex id
  -        member __.Reduce set1 set2 =
  -            CharSet.union set1 set2 }
  -
   /// <summary>Rewrites negated character sets (i.e, a set of characters *not* to be matched) into positive character sets.</summary>
   /// <param name="universe">
   /// The universe of characters for <paramref name="regex"/>; this is the set of all possible input values, whether valid or invalid.
  
positive.code: 
                  CharSet.difference ruleAlphabet initialEdgeLabels
  
              // If the set of characters matched by the wildcard pattern is not empty,
              // create a new DFA state which accepts the wildcard pattern, then add
              // 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.
                  Printf.dprintfn "Warning: Wildcard pattern in rule will never be matched."
  
                  compiledPatternDfa
  
negative.code:             // Only the earliest use of the wildcard pattern will be matched.
              let acceptingClauseIndex, neverMatchedClauseIndices = Set.extractMin wildcardClauseIndices
  
              // TODO : Return warning messages (with location info) about patterns which will never be matched.
              // TEMP : In the meantime, print warnings to the debug console for development purposes.
              neverMatchedClauseIndices
              |> Set.iter (fun clauseIndex ->
                  Printf.dprintfn "This pattern will never be matched. (ClauseIndex = %i)" <| int clauseIndex)
  
              Some acceptingClauseIndex
  
  