anchor.diff:          // Call the recursive implementation.
           orImpl regex1 regex2 id
   
  +    /// Given two regular expressions, computes (regex1 / regex2).
  +    /// The resulting expression matches any string which matches regex1
  +    /// EXCEPT for those which also match regex2.
  +    [<CompiledName("Quotient")>]
  +    let quotient regex1 regex2 =
  +        regex2
  +        |> negate
  +        |> andr regex1
  +
   
   // Add derivative methods to Regex.
   type Regex with
  +    /// Computes regex1 / regex2, given two regular expressions.
  +    /// The resulting expression matches any string which matches regex1
  +    /// EXCEPT for those which also match regex2.
  +    static member Quotient (regex1, regex2) =
  +        Regex.quotient regex1 regex2
  +
       /// Computes the derivative of a Regex with respect to a specified symbol.
       static member private DerivativeImpl wrtSymbol regex =
           cont {
           match regex with
           | Epsilon ->
               return Regex.empty
  -        | Star r as ``r*`` ->
  -            let! r' = Regex.DerivativeImpl wrtSymbol r
  -            return Regex.concat r' ``r*``
  -
  -        | Concat (r, s) ->
  -            let ``nu(r)`` = if Regex.IsNullable r then Regex.epsilon else Regex.empty
  -            let! r' = Regex.DerivativeImpl wrtSymbol r
  -            let! s' = Regex.DerivativeImpl wrtSymbol s
  -
  -            let or_r = Regex.concat r' s
  -            let or_s = Regex.concat ``nu(r)`` s'
  -            return Regex.orr or_r or_s
  -
  -        | Or (r, s) ->
  -            let! r' = Regex.DerivativeImpl wrtSymbol r
  -            let! s' = Regex.DerivativeImpl wrtSymbol s
  -            return Regex.orr r' s'
  -
  -        | And (r, s) ->
  -            let! r' = Regex.DerivativeImpl wrtSymbol r
  -            let! s' = Regex.DerivativeImpl wrtSymbol s
  -            return Regex.andr r' s'
  -
           | Any ->
               return Regex.epsilon
  -
  -        | Negate r ->
  -            let! r' = Regex.DerivativeImpl wrtSymbol r
  -            return Regex.negate r'
   
           | CharacterSet charSet ->
               return
  
positive.code: } with
      //
      static member Universe =
          {   HasEmptySet = false;
              Elements = CharSet.empty;
              Negated = CharSet.empty; }
  
      /// 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; }
  
  
  /// <summary>A regular expression.</summary>
  
negative.code:                     Regex.epsilon
                  else
                      Regex.empty
  
          | Negate r ->
              let! r' = Regex.DerivativeImpl wrtSymbol r
              return Regex.negate r'
  
          | Star r as ``r*`` ->
              let! r' = Regex.DerivativeImpl wrtSymbol r
              return Regex.concat r' ``r*``
  
          | Concat (r, s) ->
              let ``nu(r)`` = if Regex.IsNullable r then Regex.epsilon else Regex.empty
              let! r' = Regex.DerivativeImpl wrtSymbol r
              let! s' = Regex.DerivativeImpl wrtSymbol s
  
              let or_r = Regex.concat r' s
              let or_s = Regex.concat ``nu(r)`` s'
              return Regex.orr or_r or_s
  
          | Or (r, s) ->
              let! r' = Regex.DerivativeImpl wrtSymbol r
              let! s' = Regex.DerivativeImpl wrtSymbol s
              return Regex.orr r' s'
  
          | And (r, s) ->
              let! r' = Regex.DerivativeImpl wrtSymbol r
              let! s' = Regex.DerivativeImpl wrtSymbol s
              return Regex.andr r' s'
          }
  
      /// Computes the derivative of a Regex with respect to a specified symbol.
      static member Derivative symbol 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 ->
              Regex.empty
          | Any ->
              Regex.epsilon
  
          | CharacterSet charSet ->
              if CharSet.contains symbol charSet then
                  Regex.epsilon
              else
                  Regex.empty
  
          | _ ->
              Regex.DerivativeImpl symbol regex id
  
      /// Computes an approximate set of derivative classes for the specified Regex.
      static member private DerivativeClassesImpl regex =
  