fixup! refactor M.has

Author: erights

packages/nat/src/index.js

@@ -55,7 +55,7 @@ function isNat(allegedNum) {
  */
 function Nat(allegedNum) {
   if (typeof allegedNum === 'bigint') {
-    if (allegedNum < 0) {
+    if (allegedNum < 0n) {
       throw RangeError(`${allegedNum} is negative`);
     }
     return allegedNum;

packages/patterns/index.js

@@ -65,8 +65,7 @@ export {
   assertMethodGuard,
   assertInterfaceGuard,
   kindOf,
-  elementsHasSplit,
-  pairsHasSplit,
+  copyStuffHasSplit,
 } from './src/patterns/patternMatchers.js';
 
 export {

packages/patterns/package.json

@@ -36,6 +36,7 @@
     "@endo/errors": "workspace:^",
     "@endo/eventual-send": "workspace:^",
     "@endo/marshal": "workspace:^",
+    "@endo/pass-style": "workspace:^",
     "@endo/promise-kit": "workspace:^"
   },
   "devDependencies": {

packages/patterns/src/keys/merge-bag-operators.js

@@ -8,7 +8,6 @@ import { q, Fail } from '@endo/errors';
 import { assertNoDuplicateKeys, makeBagOfEntries } from './copyBag.js';
 
 /**
- * @import {Passable} from '@endo/pass-style';
  * @import {FullCompare, RankCompare} from '@endo/marshal'
  * @import {Key} from '../types.js'
  */

packages/patterns/src/patterns/patternMatchers.js

@@ -1,6 +1,11 @@
 /* eslint-disable @endo/no-optional-chaining */
 // @ts-nocheck So many errors that the suppressions hamper readability.
 // TODO parameterize MatchHelper which will solve most of them
+import { q, b, X, Fail, makeError, annotateError } from '@endo/errors';
+import { identChecker } from '@endo/common/ident-checker.js';
+import { applyLabelingError } from '@endo/common/apply-labeling-error.js';
+import { fromUniqueEntries } from '@endo/common/from-unique-entries.js';
+import { listDifference } from '@endo/common/list-difference.js';
 import {
   assertChecker,
   Far,
@@ -9,19 +14,16 @@ import {
   passStyleOf,
   hasOwnPropertyOf,
   nameForPassableSymbol,
+} from '@endo/pass-style';
+import {
   compareRank,
   getPassStyleCover,
   intersectRankCovers,
   unionRankCovers,
   recordNames,
   recordValues,
 } from '@endo/marshal';
-import { identChecker } from '@endo/common/ident-checker.js';
-import { applyLabelingError } from '@endo/common/apply-labeling-error.js';
-import { fromUniqueEntries } from '@endo/common/from-unique-entries.js';
-import { listDifference } from '@endo/common/list-difference.js';
 
-import { q, b, X, Fail, makeError, annotateError } from '@endo/errors';
 import { keyEQ, keyGT, keyGTE, keyLT, keyLTE } from '../keys/compareKeys.js';
 import {
   assertKey,
@@ -34,6 +36,8 @@ import {
   checkCopyBag,
   getCopyMapEntryArray,
   makeCopyMap,
+  makeCopySet,
+  makeCopyBag,
 } from '../keys/checkKey.js';
 import { generateCollectionPairEntries } from '../keys/keycollection-operators.js';
 
@@ -1311,8 +1315,8 @@ const makePatternKit = () => {
    * @param {bigint} bound Must be >= 1n
    * @param {CopyArray<[Key, bigint]>} [inResults]
    * @param {CopyArray<[Key, bigint]>} [outResults]
-   * @returns {boolean}
    * @param {Checker} [check]
+   * @returns {boolean}
    */
   const pairsHasSplit = (
     pairs,
@@ -1330,7 +1334,7 @@ const makePatternKit = () => {
     // results. It is more intuitive for the choice to be the first `bound`
     // matching elements in ascending lexicigraphic order, rather than
     // decending. Thus we iterate `pairs` in reverse order.
-    for (let i = pairs.length - 1; i >= 0n; i -= 1) {
+    for (let i = pairs.length - 1; i >= 0; i -= 1) {
       const [element, num] = pairs[i];
       const numRest = bound - count;
       if (numRest >= 1n) {
@@ -1359,6 +1363,87 @@ const makePatternKit = () => {
     );
   };
 
+  /**
+   * @typedef {CopyArray | CopySet | CopyBag} CopyStuff
+   * @typedef {CopyTagged<'match:has'>} CopyStuffHasBound
+   * @param {CopyStuff} specimen
+   * @param {Pattern} elementPatt
+   * @param {bigint} bound Must be >= 1n
+   * @param {boolean} [needInResults]
+   * @param {boolean} [needOutResults]
+   * @param {Checker} [check]
+   * @returns {[CopyStuff | undefined, CopyStuff | undefined] | false}
+   */
+  const copyStuffHasSplit = (
+    specimen,
+    elementPatt,
+    bound,
+    needInResults = false,
+    needOutResults = false,
+    check = identChecker,
+  ) => {
+    const inResults = needInResults ? [] : undefined;
+    const outResults = needOutResults ? [] : undefined;
+    const kind = kindOf(specimen);
+    switch (kind) {
+      case 'copyArray': {
+        if (
+          !elementsHasSplit(
+            specimen,
+            elementPatt,
+            bound,
+            inResults,
+            outResults,
+            check,
+          )
+        ) {
+          // check logic already performed by elementsHasSplit
+          return false;
+        }
+        return [inResults, outResults];
+      }
+      case 'copySet': {
+        if (
+          !elementsHasSplit(
+            specimen.payload,
+            elementPatt,
+            bound,
+            inResults,
+            outResults,
+            check,
+          )
+        ) {
+          return false;
+        }
+        return [
+          inResults && makeCopySet(inResults),
+          inResults && makeCopySet(inResults),
+        ];
+      }
+      case 'copyBag': {
+        if (
+          !pairsHasSplit(
+            specimen.payload,
+            elementPatt,
+            bound,
+            inResults,
+            outResults,
+            check,
+          )
+        ) {
+          return false;
+        }
+        return [
+          inResults && makeCopyBag(inResults),
+          inResults && makeCopyBag(inResults),
+        ];
+      }
+      default: {
+        return check(false, X`unexpected ${q(kind)}`);
+      }
+    }
+  };
+
   /** @type {MatchHelper} */
   const matchHasHelper = Far('match:has helper', {
     /**
@@ -1382,41 +1467,14 @@ const makePatternKit = () => {
       ) {
         return false;
       }
-      switch (kind) {
-        case 'copyArray': {
-          return elementsHasSplit(
-            specimen,
-            elementPatt,
-            bound,
-            undefined,
-            undefined,
-            check,
-          );
-        }
-        case 'copySet': {
-          return elementsHasSplit(
-            specimen.payload,
-            elementPatt,
-            bound,
-            undefined,
-            undefined,
-            check,
-          );
-        }
-        case 'copyBag': {
-          return pairsHasSplit(
-            specimen.payload,
-            elementPatt,
-            bound,
-            undefined,
-            undefined,
-            check,
-          );
-        }
-        default: {
-          return check(false, X`unexpected ${q(kind)}`);
-        }
-      }
+      return !!copyStuffHasSplit(
+        specimen,
+        elementPatt,
+        bound,
+        false,
+        false,
+        check,
+      );
     },
 
     checkIsWellFormed: (payload, check) =>
@@ -1938,8 +1996,7 @@ const makePatternKit = () => {
     getRankCover,
     M,
     kindOf,
-    elementsHasSplit,
-    pairsHasSplit,
+    copyStuffHasSplit,
   });
 };
 
@@ -1958,8 +2015,7 @@ export const {
   getRankCover,
   M,
   kindOf,
-  elementsHasSplit,
-  pairsHasSplit,
+  copyStuffHasSplit,
 } = makePatternKit();
 
 MM = M;