fixup! abstract helper iterations

Author: erights

packages/ERTP/src/mathHelpers/setMathHelpers.js

@@ -1,7 +1,7 @@
 // @jessie-check
 
 import { Fail, q } from '@endo/errors';
-import { passStyleOf } from '@endo/pass-style';
+import { passStyleOf, mapIterable } from '@endo/pass-style';
 import { isKey, assertKey, mustMatch, matches } from '@endo/patterns';
 import {
   elementsIsSuperset,
@@ -12,6 +12,93 @@ import {
 } from '@agoric/store';
 import { AmountValueHasBoundShape } from '../typeGuards.js';
 
+/**
+ * @import {Passable} from '@endo/pass-style'
+ * @import {AmountValueHasBound} from '../types.js'
+ */
+
+/**
+ * @param {Iterable<[Passable, bigint]>} leftEntries
+ * @param {AmountValueHasBound} rightBound
+ * @returns {boolean}
+ */
+export const entriesIsGTEHasBound = (leftEntries, rightBound) => {
+  mustMatch(rightBound, AmountValueHasBoundShape, 'right value bound');
+  const {
+    payload: [elementPatt, bound],
+  } = rightBound;
+  if (bound === 0n) {
+    return true;
+  }
+  let count = 0n;
+  for (const [element, num] of leftEntries) {
+    if (matches(element, elementPatt)) {
+      count += num;
+    }
+    if (count >= bound) {
+      return true;
+    }
+  }
+  return false;
+};
+ 
+/**
+ * @param {Iterable<[Passable, bigint]>} leftEntries
+ * @param {AmountValueHasBound} rightBound
+ * @returns {Iterable<[Passable, bigint]>}
+ */
+export const entriesMinusHasBound = (leftEntries, rightBound) => {
+  mustMatch(rightBound, AmountValueHasBoundShape, 'right value bound');
+  const {
+    payload: [elementPatt, bound],
+  } = rightBound;
+  if (bound === 0n) {
+    return leftEntries;
+  }
+  return harden({
+    // eslint-disable-next-line no-restricted-globals
+    [Symbol.iterator]() {
+      // eslint-disable-next-line no-restricted-syntax, no-restricted-globals
+      const entriesIterator = leftEntries[Symbol.iterator]();
+      let count = 0n;
+      return harden({
+        next() {
+          for (;;) {
+            const { done, value } =
+              /** @type {IteratorResult<[Passable, bigint]>} */ (
+                entriesIterator.next()
+              );
+            if (done) {
+              if (count !== bound) {
+                if (count < bound) {
+                  throw Fail`Only has ${q(count)} matches, but needs at least ${bound}`;
+                }
+                throw Fail`internal: ${q(count)} should not get ahead of ${q(bound)}`;
+              }
+              return harden({ done: true, value: undefined });
+            }
+            const [element, num] = value;
+            if (count === bound) {
+              return harden({ done: false, value: [element, num] });
+            }
+            if (matches(element, elementPatt)) {
+              const numRest = bound - count;
+              if (num <= numRest) {
+                count += num;
+              } else {
+                count = bound;
+                return harden({ done: false, value: [element, num - numRest] });
+              }
+            } else {
+              return harden({ done: false, value: [element, num] });
+            }
+          }
+        },
+      });
+    },
+  });
+};
+
 /**
  * @import {Key} from '@endo/patterns'
  * @import {MathHelpers, SetValue} from '../types.js'
@@ -42,52 +129,26 @@ export const setMathHelpers = harden({
     if (isKey(rightBound)) {
       return elementsIsSuperset(left, rightBound);
     }
-    mustMatch(rightBound, AmountValueHasBoundShape, 'right value bound');
-    const {
-      payload: [elementPatt, bound],
-    } = rightBound;
-    if (bound === 0n) {
-      return true;
-    }
-    let count = 0n;
-    for (const element of left) {
-      if (matches(element, elementPatt)) {
-        count += 1n;
-      }
-      if (count >= bound) {
-        return true;
-      }
-    }
-    return false;
+    const leftEntries = mapIterable(left, el =>
+      harden(/** @type {[Passable, bigint]} */ ([el, 1n])),
+    );
+    return entriesIsGTEHasBound(leftEntries, rightBound);
   },
   doIsEqual: (x, y) => elementsCompare(x, y) === 0,
   doAdd: elementsDisjointUnion,
   doSubtract: (left, rightBound) => {
     if (isKey(rightBound)) {
       return elementsDisjointSubtract(left, rightBound);
     }
-    mustMatch(rightBound, AmountValueHasBoundShape, 'right value bound');
-    const {
-      payload: [elementPatt, bound],
-    } = rightBound;
-    if (bound === 0n) {
-      return left;
-    }
-    let count = 0n;
+    const leftEntries = mapIterable(left, el =>
+      harden(/** @type {[Passable, bigint]} */ ([el, 1n])),
+    );
+    const remainingEntries = entriesMinusHasBound(leftEntries, rightBound);
     const result = [];
-    for (const element of left) {
-      if (count < bound) {
-        if (matches(element, elementPatt)) {
-          count += 1n;
-        } else {
-          result.push(element);
-        }
-      } else {
-        result.push(element);
-      }
+    for (const [element, num] of remainingEntries) {
+      num === 1n || Fail`Set subtract elements can only occur once`;
+      result.push(element);
     }
-    count >= bound ||
-      Fail`Only has ${q(count)} matches, but needs at least ${bound}`;
-    return result;
+    return harden(result);
   },
 });