perf(enumerate): speed up with memoization

Author: gruhn

src/index.ts

@@ -300,8 +300,8 @@ class RegexBuilder {
    * "a", "b", "aa", "bb", "aaa", "bbb", "aaaa", "bbbb", ...
    * ```
    */
-  enumerate() {
-    return RE.enumerate(this.getStdRegex())
+  *enumerate() {
+    yield* RE.enumerate(this.getStdRegex())
   }
 
   /**

src/regex.ts

@@ -754,16 +754,27 @@ function extractConcatChain(left: StdRegex, right: StdRegex): [number, StdRegex
   }
 }
 
-/**
- * TODO
- * 
- * @public
- */
-export function* enumerate(re: StdRegex): Generator<string> {
-  yield* enumerateAux(re)
+export function enumerate(regex: StdRegex): Stream.Stream<string> {
+  return enumerateMemoized(regex, new Map())
 }
 
-export function enumerateAux(regex: StdRegex): Stream.Stream<string> {
+function enumerateMemoized(
+  regex: StdRegex,
+  cache: Map<number, Stream.Stream<string> | undefined>
+): Stream.Stream<string> {
+  const cached = cache.get(regex.hash)
+  if (cached !== undefined) {
+    return cached
+  } else {
+    const result = enumerateMemoizedAux(regex, cache)
+    cache.set(regex.hash, result)
+    return result
+  }
+}
+function enumerateMemoizedAux(
+  regex: StdRegex,
+  cache: Map<number, Stream.Stream<string> | undefined>
+): Stream.Stream<string> {
   switch (regex.type) {
     case 'epsilon':
       return Stream.singleton('')
@@ -772,21 +783,21 @@ export function enumerateAux(regex: StdRegex): Stream.Stream<string> {
     case 'concat':
       return Stream.diagonalize(
         (l,r) => l+r,
-        enumerateAux(regex.left),
-        enumerateAux(regex.right),
+        enumerateMemoized(regex.left, cache),
+        enumerateMemoized(regex.right, cache),
       )
     case 'union':
       return Stream.interleave(
-        enumerateAux(regex.left),
-        enumerateAux(regex.right),
+        enumerateMemoized(regex.left, cache),
+        enumerateMemoized(regex.right, cache),
       )
     case 'star':
       return Stream.cons(
         '',
         () => Stream.diagonalize(
           (l,r) => l+r,
-          enumerateAux(regex.inner),
-          enumerateAux(regex),
+          enumerateMemoized(regex.inner, cache),
+          enumerateMemoized(regex, cache),
         )
       )
   }

test/regex.spec.ts

@@ -60,7 +60,7 @@ describe('enumerate', () => {
         Arb.stdRegex(),
         inputRegex => {
           const regexp = RE.toRegExp(inputRegex)
-          const allWords = RE.enumerateAux(inputRegex)
+          const allWords = RE.enumerate(inputRegex)
 
           // long words are likely result of repitiion and are less interesting to test
           // and also blow up memory use:
@@ -84,7 +84,7 @@ describe('enumerate', () => {
 
           // get words NOT in the output by enumerating words of the complement:
           const inputRegexComplement = toStdRegex_ignoreBlowUp(RE.complement(inputRegex))
-          const allComplementWords = RE.enumerateAux(inputRegexComplement)
+          const allComplementWords = RE.enumerate(inputRegexComplement)
 
           // long words are likely result of repetition and are less interesting to test
           // and also blow up memory:
@@ -152,7 +152,7 @@ describe('size', () => {
           const predicatedSize = RE.size(stdRegex)
           fc.pre(predicatedSize !== undefined && predicatedSize <= 100n)
 
-          const allWords = [...RE.enumerateAux(stdRegex)]
+          const allWords = [...RE.enumerate(stdRegex)]
           assert.equal(predicatedSize, BigInt(allWords.length))
         }       
       )