anchor.diff:  } with
       //
       static member Universe =
  -        {   HasEmptySet = false;
  -            Elements = CharSet.empty;
  -            Negated = CharSet.empty; }
  +      { HasEmptySet = false;
  +        Elements = CharSet.empty;
  +        Negated = CharSet.empty; }
  +
  +    //
  +    static member UniversePlusEmptySet =
  +      { DerivativeClasses.Universe
  +            with HasEmptySet = true; }
   
       /// 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 Intersect (``C(r)``, ``C(s)``) =
  -        {   HasEmptySet =
  -                ``C(r)``.HasEmptySet || ``C(s)``.HasEmptySet;
  -            Elements =
  -                CharSet.union ``C(r)``.Elements ``C(s)``.Elements;
  -            Negated =
  -                CharSet.union ``C(r)``.Negated ``C(s)``.Negated; }
  +      { HasEmptySet =
  +            ``C(r)``.HasEmptySet || ``C(s)``.HasEmptySet;
  +        Elements =
  +            CharSet.union ``C(r)``.Elements ``C(s)``.Elements;
  +        Negated =
  +            CharSet.union ``C(r)``.Negated ``C(s)``.Negated; }
   
   
   /// <summary>A regular expression.</summary>
  
positive.code:                     Regex.epsilon
                  else
                      Regex.empty
          }
  
      /// Computes the derivative of a Regex with respect to a specified symbol.
      static member Derivative symbol regex =
          Regex.DerivativeImpl symbol regex id
  
      /// Computes an approximate set of derivative classes for the specified Regex.
      static member private DerivativeClassesImpl regex =
  
negative.code: 
      /// Computes an approximate set of derivative classes for the specified Regex.
      static member DerivativeClasses (regex : Regex) =
          // OPTIMIZATION : Immediately return the result for some patterns instead of calling
          // the continuation-based method -- this eliminates the overhead of creating/calling
          // the continuations for some very common cases.
          match regex with
          | Epsilon ->
              DerivativeClasses.Universe
          | Any ->
              DerivativeClasses.UniversePlusEmptySet
          | CharacterSet charSet ->
              { HasEmptySet = false;
                  Elements = charSet;
                  Negated = charSet; }
          | _ ->
              Regex.DerivativeClassesImpl regex id
  
  
  /// An array of regular expressions.
  