anchor.diff:                  |> cont
   
       /// Creates a new Regex in canonical form from the given Regex.
  -    static member Canonicalize (regex : Regex, charUniverse) : Regex =
  +    static member Canonicalize (regex : Regex, universe) : Regex =
           // Preconditions
  -        if CharSet.isEmpty charUniverse then
  -            invalidArg "charUniverse" "The character universe (set of all characters used in the lexer) is empty."
  +        if CharSet.isEmpty universe then
  +            invalidArg "universe" "The character universe (set of all characters used in the lexer) is empty."
           
  -        Regex.CanonicalizeImpl regex charUniverse id
  -
  -    /// Computes a conservative approximation of the derivative class of
  -    /// a compound regular expression ('And', 'Or', and 'Concat') from
  -    /// the derivative classes of its component expressions.
  -    static member private DerivativeClassOfCompoundRegex (``C(r)``, ``C(s)``) =
  +        Regex.CanonicalizeImpl regex universe id
  +
  +    /// Computes a conservative approximation of the intersection of two sets of
  +    /// derivative classes. This is needed when computing the set of derivative
  +    /// classes for a compound regular expression ('And', 'Or', and 'Concat').
  +    static member IntersectionOfDerivativeClasses (``C(r)``, ``C(s)``) =
           (Set.empty, ``C(r)``)
           ||> Set.fold (fun intersections el1 ->
               (intersections, ``C(s)``)
  
positive.code:             else
                  Regex.DerivativeClassesImpl r universe <| fun ``C(r)`` ->
                  Regex.DerivativeClassesImpl s universe <| fun ``C(s)`` ->
                      Regex.DerivativeClassOfCompoundRegex (``C(r)``, ``C(s)``)
                      |> cont
          | Or (r, s)
          | And (r, s) ->
              Regex.DerivativeClassesImpl r universe <| fun ``C(r)`` ->
              Regex.DerivativeClassesImpl s universe <| fun ``C(s)`` ->
                  Regex.DerivativeClassOfCompoundRegex (``C(r)``, ``C(s)``)
                  |> cont
  
      /// Computes the _approximate_ set of derivative classes for the specified Regex.
      static member DerivativeClasses (regex : Regex, charUniverse) =
          // Preconditions
          if CharSet.isEmpty charUniverse then
              invalidArg "charUniverse" "The character universe (set of all characters used in the lexer) is empty."
          
          Regex.DerivativeClassesImpl regex charUniverse id
  
  
  /// An extended regular expression: a standard regular expression
  
negative.code:     | Any
      /// A character.
      | Character of char
      /// The specified ExtendedRegex is matched one (1) or more times.
      /// This is the Plus (+) operator in a regular expression.
      | OneOrMore of ExtendedRegex
  