rewrite rule for sort union members

Sorting union members automatically eliminates duplicates in unions.
That reduces expression size and in particluar avoids call-stack
overflows in the benchmark for instances with otherwise very deep
expression trees. However, overall expressions are even larger at
times and the sorting step also has a performance cost.

Author: gruhn

benchmark/toStdRegex_output_length.js

@@ -7,35 +7,8 @@ let avgMult = 0
 let maxMult = -Infinity
 
 const hardInstances = new Set([
-  290, // call-stack overflow
-  556, // ???
-  658, // ???
-  689, // call-stack overflow
-  724, // ???
-  777, // ???
-  783, // out of memory
-  787, // ??? 
-  791, // ???
-  831, // ???
-  840, // stack overflow
-  860, // ???
-  871, // ???
   883, // ???
-  884, // ???
-  894, // ???
-  900, // stack overflow
-  908, // ???
-  940, // ???
-  948, // ???
-  949, // ???
-  954, // ???
-  958, // ???
-  961, // stack overflow
   964, // ???
-  981, // ???
-  991, // ???
-  994, // ???
-  996, // ???
 ])
 
 function run(inputRegExp, index) {
@@ -61,6 +34,8 @@ function run(inputRegExp, index) {
       avg. multiplier     : ${avgMult}
       worst multiplier    : ${maxMult}
     `) 
+
+    console.log('#' + index, outputRegExp)
   } catch (err) {
     console.log('too many captures')
   }
@@ -73,10 +48,10 @@ const regexDatasetSorted = regexDataset.sort(
   (a,b) => a.source.length - b.source.length
 )
 
-run(regexDatasetSorted[689], 689)
+run(regexDatasetSorted[689], 0)
 
 // regexDatasetSorted
-//   .filter(inst => !hardInstances.includes(inst))
+//   .filter((inst, i) => !hardInstances.has(i))
 //   .forEach(run)
 
 console.log('time:', performance.now() - timeStart)

src/regex.ts

@@ -177,20 +177,18 @@ export function union(left: ExtRegex, right: ExtRegex): ExtRegex {
     // r* + ε = r*
     return left
 
+  // These rules sort union members and eliminate duplicates, e.g.
+  // /b|a|b/ --> /a|b|b/ --> /a|b/
   if (right.type == 'union') {
     if (equal(left, right.left))
       // r + (r + s) = r + s
       return union(left, right.right)
     if (equal(left, right.right))
       // r + (s + r) = r + s
       return union(left, right.left)
-
-    // const [leftHead, leftTail] = extractFront(left)
-    // const [rightHead, rightTail] = extractFront(right.left)
-    // if (equal(leftHead, rightHead))
-    //   // (r · s) + ((r · t) + u) = (r · (s + t)) + u
-    //   return union(concat(left, union(leftTail, rightTail)), right.right)
-    //   // return concat(left, optional(union(leftTail, right.right)))
+    if (left.hash > right.left.hash)
+      // s + (r + t) = r + (s + t)
+      return union(right.left, union(left, right.right))
   }
 
   const [leftHead, leftTail] = extractFront(left)