anchor.diff:                  |> cont
           | Star r as ``r*`` ->
               Regex.DerivativeImpl wrtSymbol r <| fun r' ->
  -                Concat (r', ``r*``)
  +                Or (Epsilon,
  +                    Concat (r', ``r*``))
                   |> cont
           | Concat (r, s) ->
               let ``nu(r)`` = if Regex.IsNullable r then Epsilon else Empty
  
positive.code:         // Return the computed set of indices.
          accepting
  
      /// The indices of the element expressions (if any)
      /// that accept the empty string (epsilon).
      let acceptingElementsTagged< [<Measure>] 'Tag > (regVec : RegularVector) =
          /// The indices of the expressions accepting the empty string.
          let mutable accepting = Set.empty
  
          let len = Array.length regVec
          for i = 0 to len - 1 do
              if Regex.IsNullable regVec.[i] then
                  accepting <- Set.add (Int32WithMeasure<'Tag> i) accepting
  
          // Return the computed set of indices.
          accepting
  
      /// Determines if a regular vector is an empty vector. Note that an
      /// empty regular vector is *not* the same thing as an empty array.
      let inline isEmpty (regVec : RegularVector) =
  
negative.code:         | Epsilon ->
              cont Empty
          | Any ->
              cont Epsilon
          | Character c ->
              if c = wrtSymbol then Epsilon else Empty
  