feat: more Set-like operations

Author: gruhn

README.md

@@ -3,12 +3,19 @@
 Zero-dependency TypeScript library for regex utilities that go beyond string matching.
 These are surprisingly hard to come by for any programming language.
 
-- [.and(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#and) - Compute intersection of two regex.
-- [.not(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#not) - Compute the complement of a regex.
-- [.isEquivalent(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#isEquivalent) - Check whether two regex match the same strings.
-- [.size()](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#size) - Count the number of strings that a regex matches.
-- [.enumerate()](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#enumerate) - Generate strings matching a regex.
-- [.derivative(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#derivative) - Compute a Brzozowski derivative of a regex.
+- Set-like operations:
+  - [.and(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#and) - Compute intersection of two regex.
+  - [.not()](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#not) - Compute the complement of a regex.
+  - [.without(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#without) - Compute the difference of two regex.
+- Set-like predicates:
+  - [.isEquivalent(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#isEquivalent) - Check whether two regex match the same strings.
+  - [.isSubsetOf(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#isSubsetOf)
+  - [.isSupersetOf(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#isSupersetOf)
+  - [.isDisjointFrom(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#isDisjointFrom)
+- Miscellaneous:
+  - [.size()](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#size) - Count the number of strings that a regex matches.
+  - [.enumerate()](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#enumerate) - Generate strings matching a regex.
+  - [.derivative(...)](https://gruhn.github.io/regex-utils/classes/RegexBuilder.html#derivative) - Compute a Brzozowski derivative of a regex.
 
 ## Installation
 

src/dfa.ts

@@ -206,7 +206,7 @@ export function toStdRegex(inputRegex: RE.ExtRegex): RE.StdRegex {
  *
  * TODO: maybe expose `equal` as dedicated function.
  */
-export function equivalent(regexA: RE.ExtRegex, regexB: RE.ExtRegex): boolean {
+export function isEquivalent(regexA: RE.ExtRegex, regexB: RE.ExtRegex): boolean {
   if (RE.equal(regexA, regexB)) { // First check hash based equality: cheap but weak.
     return true
   } else {

src/index.ts

@@ -1,4 +1,4 @@
-import { equivalent as isEquivalent, toStdRegex } from './dfa'
+import { isEquivalent, toStdRegex } from './dfa'
 import * as RE from './regex'
 import { parseRegExp } from './regex-parser'
 
@@ -337,6 +337,50 @@ class RegexBuilder {
   isEquivalent(re: RegexLike): boolean {
     return isEquivalent(this.regex, fromRegexLike(re))
   }
+
+  /**
+   * Constructs the difference of the current regex and `re`.
+   * That is, this returns a new regex which matches all strings that
+   * the current regex matches EXCEPT everything that `re` matches.
+   *
+   * @example
+   * ```typescript 
+   * RB(/^a*$/).without(/^a{5}$/) // /^(a{0,4}|a{6,})$/
+   * ```
+   *
+   * @public
+   */
+  without(re: RegexLike): RegexBuilder {
+    return this.and(RB(re).not())
+  }
+
+  /**
+   * TODO
+   *
+   * @public
+   */
+  isSubsetOf(re: RegexLike): boolean {
+    return this.without(re).isEmpty()
+  }
+
+  /**
+   * TODO
+   *
+   * @public
+   */
+  isSupersetOf(re: RegexLike): boolean {
+    return RB(re).without(this).isEmpty()
+  }
+
+  /**
+   * TODO
+   *
+   * @public
+   */
+  isDisjointFrom(re: RegexLike): boolean {
+    return this.and(RB(re)).isEmpty()
+  }
+ 
 }
 
 /**

test/index.spec.ts

@@ -73,8 +73,20 @@ describe('isEquivalent', () => {
   ])('%s is not equivalent to %s', (re1, re2) => {
     expect(RB(re1).isEquivalent(re2)).toBe(false)
   })
+
 })
 
+describe('without', () => {
+
+  test.each([
+    [/^a*$/, /^a{3,10}$/, /^(a{,2}|a{11,})$/],
+  ])('%s without %s is %s', (re1, re2, expected) => {
+    const actual = RB(re1).without(re2)
+    expectSubsetOf(RB(expected), actual)
+    expectSubsetOf(actual, RB(expected))
+  })
+
+})
 
 test('A ∩ ¬A = ∅', () => {
   fc.assert(