functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/types/btree/proof.f.js

@@ -5,6 +5,7 @@ import { cmp } from '../string/module.f.js';
 import { next, toArray } from '../list/module.f.js';
 import { set as setSet } from './set/module.f.js';
 import { value, find as findFind } from './find/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const jsonStr = jsonStringify(sort);
 const stringify = sequence => jsonStr(toArray(sequence));
 const set = node => value => setSet(cmp(value))(() => value)(node);
@@ -16,36 +17,28 @@ const valueTest1 = () => {
     _map = set(_map)('e');
     _map = set(_map)('f');
     const result = stringify(values(_map));
-    if (result !== '["a","b","c","d","e","f"]') {
-        throw result;
-    }
+    assertEq(result, '["a","b","c","d","e","f"]');
 };
 const valuesTest2 = () => {
     let _map = ['1'];
     for (let i = 2; i <= 10; i++)
         _map = set(_map)((i * i).toString());
     const result = stringify(values(_map));
-    if (result !== '["1","100","16","25","36","4","49","64","81","9"]') {
-        throw result;
-    }
+    assertEq(result, '["1","100","16","25","36","4","49","64","81","9"]');
 };
 const findTrue = () => {
     let _map = ['a'];
     _map = set(_map)('b');
     _map = set(_map)('c');
     const result = value(findFind(cmp('b'))(_map).first);
-    if (result !== 'b') {
-        throw result;
-    }
+    assertEq(result, 'b');
 };
 const find = () => {
     let _map = ['a'];
     _map = set(_map)('b');
     _map = set(_map)('c');
     const result = value(findFind(cmp('e'))(_map).first);
-    if (result !== null) {
-        throw result;
-    }
+    assertEq(result, null);
 };
 const test = () => {
     let _map = ['a'];

package/{fs → fjs}/types/btree/remove/module.f.d.ts

@@ -7,3 +7,8 @@ import { type TNode, type Tree } from '../types/module.f.ts';
 import type { Compare } from '../../function/compare/module.f.ts';
 export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
 export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;
+export declare const proof: {
+    throw: {
+        reduceValue0DefaultBranch: () => void;
+    };
+};

package/{fs → fjs}/types/btree/remove/module.f.js

@@ -172,3 +172,15 @@ export const nodeRemove = (c) => (node) => {
     return collapseRoot(reduce(initReduce(tf)(first))(tt));
 };
 export const remove = c => map(nodeRemove(c));
+// `reduceValue0`/`reduceValue2`/`initValue0`/`initValue1` merge a Branch1's lone
+// child into its Branch3 sibling. The sibling is always a Branch (length 3 or 5)
+// in every reachable tree shape, so the `default` arm guarding a mismatched
+// (leaf) sibling length can't be hit through the public `remove` API. Exercise
+// it directly here so the invariant guard itself stays covered.
+export const proof = {
+    throw: {
+        reduceValue0DefaultBranch: () => {
+            reduceValue0([['leaf']])([['x'], 's', ['y']]);
+        },
+    },
+};

package/{fs → fjs}/types/btree/remove/proof.f.d.ts

@@ -1,7 +1,9 @@
 declare const test: () => void;
 declare const test2: () => void;
+declare const test3: () => void;
 export declare const proof: {
     test: typeof test;
     test2: typeof test2;
+    test3: typeof test3;
 };
 export {};