functionalscript 0.1.609 → 0.2.1

package/out/types/bigint/test.f.mjs

@@ -0,0 +1,192 @@
+import * as _ from './module.f.mjs';
+const { sum, abs, serialize, log2, bitLength } = _;
+export default {
+    sum: () => {
+        const result = sum([2n, 3n, 4n, 5n]);
+        if (result !== 14n) {
+            throw result;
+        }
+    },
+    abs: [
+        () => {
+            const result = abs(10n);
+            if (result !== 10n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = abs(-10n);
+            if (result !== 10n) {
+                throw result;
+            }
+        }
+    ],
+    serialize: [
+        () => {
+            const result = serialize(0n);
+            if (result !== '0n') {
+                throw result;
+            }
+        },
+        () => {
+            const result = serialize(123456789012345678901234567890n);
+            if (result !== '123456789012345678901234567890n') {
+                throw result;
+            }
+        },
+        () => {
+            const result = serialize(-55555n);
+            if (result !== '-55555n') {
+                throw result;
+            }
+        },
+    ],
+    log2: [
+        () => {
+            const result = log2(-3n);
+            if (result !== -1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(0n);
+            if (result !== -1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(1n);
+            if (result !== 0n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(2n);
+            if (result !== 1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(3n);
+            if (result !== 1n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(4n);
+            if (result !== 2n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(7n);
+            if (result !== 2n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(8n);
+            if (result !== 3n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(15n);
+            if (result !== 3n) {
+                throw result;
+            }
+        },
+        () => {
+            const result = log2(16n);
+            if (result !== 4n) {
+                throw result;
+            }
+        },
+        () => {
+            // max for Bun (131_072 Bytes)
+            const v = 1048575n;
+            const result = log2(1n << v);
+            if (result !== v) {
+                throw result;
+            }
+        },
+    ],
+    toString2: () => {
+        // max for Bun (131_072 Bytes)
+        const v = 1048575n;
+        const result = (1n << v).toString(2).length - 1;
+        if (result !== 1_048_575) {
+            throw result;
+        }
+    },
+    minus: () => {
+        let i = 0n;
+        while (i < 1048575n) {
+            const s = -i;
+            if (i !== -s) {
+                throw [i, s];
+            }
+            i += 1n;
+        }
+    },
+    not: () => {
+        let i = 0n;
+        while (i < 1048575n) {
+            const s = ~i;
+            if (i !== ~s) {
+                throw [i, s];
+            }
+            i += 1n;
+        }
+    },
+    bitLen: {
+        0: () => {
+            const s = bitLength(0n);
+            if (s !== 0n) {
+                throw s;
+            }
+        },
+        m: () => {
+            let i = 0n;
+            while (i < 10000n) {
+                const s = bitLength(1n << i);
+                if (s !== i + 1n) {
+                    throw [s, i];
+                }
+                i += 1n;
+            }
+        },
+        big: () => {
+            const s = bitLength(1n << 1000000n);
+            if (s !== 1000001n) {
+                throw s;
+            }
+        },
+        neg: [
+            () => {
+                const s = bitLength(-1n);
+                if (s !== 1n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-2n);
+                if (s !== 2n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-3n);
+                if (s !== 2n) {
+                    throw s;
+                }
+            },
+            () => {
+                const s = bitLength(-4n);
+                if (s !== 3n) {
+                    throw s;
+                }
+            },
+        ]
+    }
+};

package/{types → out/types}/btree/find/module.f.d.mts

@@ -1,12 +1,23 @@
-declare namespace _default {
-    export { find };
-    export { value };
-    export { isFound };
-}
-export default _default;
-export type FirstLeaf1<T> = readonly [cmpT.Index3, _.Leaf1<T>];
+/**
+ * @template T
+ * @typedef {List.List<PathItem<T>>} Path
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: First<T>,
+ *  readonly tail: Path<T>
+ * }} Result<T>
+ */
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+export const find: <T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>;
+/** @type {<T>(first: First<T>) => boolean} */
+export const isFound: <T>(first: First<T>) => boolean;
+/** @type {<T>(first: First<T>) => T | null} */
+export const value: <T>(first: First<T>) => T | null;
+export type FirstLeaf1<T> = readonly [cmp.Index3, _.Leaf1<T>];
 export type FirstBranch3<T> = readonly [1, _.Branch3<T>];
-export type FirstLeaf2<T> = readonly [cmpT.Index5, _.Leaf2<T>];
+export type FirstLeaf2<T> = readonly [cmp.Index5, _.Leaf2<T>];
 export type FirstBranch5<T> = readonly [1 | 3, _.Branch5<T>];
 export type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>;
 export type PathItem3<T> = readonly [0 | 2, _.Branch3<T>];
@@ -20,23 +31,6 @@ export type Result<T> = {
     readonly first: First<T>;
     readonly tail: Path<T>;
 };
-/**
- * @template T
- * @typedef {List.List<PathItem<T>>} Path
- */
-/**
- * @template T
- * @typedef {{
- *  readonly first: First<T>,
- *  readonly tail: Path<T>
- * }} Result<T>
- */
-/** @type {<T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>} */
-declare const find: <T>(c: cmpT.Compare<T>) => (node: _.Node<T>) => Result<T>;
-/** @type {<T>(first: First<T>) => T | null} */
-declare const value: <T>(first: First<T>) => T | null;
-/** @type {<T>(first: First<T>) => boolean} */
-declare const isFound: <T>(first: First<T>) => boolean;
-import * as cmpT from '../../function/compare/module.f.mjs';
+import * as cmp from '../../function/compare/module.f.mjs';
 import * as _ from '../types/module.f.mjs';
 import * as List from '../../list/module.f.mjs';

package/out/types/btree/find/module.f.mjs

@@ -0,0 +1,137 @@
+// @ts-self-types="./module.f.d.mts"
+import * as _ from '../types/module.f.mjs';
+import * as List from '../../list/module.f.mjs';
+import * as cmp from '../../function/compare/module.f.mjs';
+const { index3, index5 } = cmp;
+import * as Array from '../../array/module.f.mjs';
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index3, _.Leaf1<T>]} FirstLeaf1
+ */
+/**
+ * @template T
+ * @typedef {readonly[1, _.Branch3<T>]} FirstBranch3
+ */
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index5, _.Leaf2<T>]} FirstLeaf2
+ */
+/**
+ * @template T
+ * @typedef {readonly[1|3, _.Branch5<T>]} FirstBranch5
+ */
+/**
+ * @template T
+ * @typedef {FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>} First
+ */
+/**
+ * @template T
+ * @typedef {readonly[0|2, _.Branch3<T>]} PathItem3
+ */
+/**
+ * @template T
+ * @typedef {readonly[0|2|4, _.Branch5<T>]} PathItem5
+ */
+/**
+ * @template T
+ * @typedef {PathItem3<T> | PathItem5<T>} PathItem
+ */
+/** @type {<T>(item: PathItem<T>) => _.Node<T>} */
+const child = item => 
+/** @type {typeof item extends PathItem<infer T> ? _.Node<T> : never} */ (item[1][item[0]]);
+/**
+ * @template T
+ * @typedef {List.List<PathItem<T>>} Path
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: First<T>,
+ *  readonly tail: Path<T>
+ * }} Result<T>
+ */
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+export const find = c => {
+    const i3 = index3(c);
+    const i5 = index5(c);
+    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
+    /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
+    const f = tail => node => {
+        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
+        const append = index => {
+            const first = /** @type {PathItem<T>} */ ([index, node]);
+            return f({ first, tail })(child(first));
+        };
+        /** @type {(index: Array.KeyOf<typeof node>) => Result<T>} */
+        const done = index => ({ first: /** @type {First<T>} */ ([index, node]), tail });
+        switch (node.length) {
+            case 1: {
+                return done(i3(node[0]));
+            }
+            case 2: {
+                return done(i5(node));
+            }
+            case 3: {
+                const i = i3(node[1]);
+                switch (i) {
+                    case 0:
+                    case 2: {
+                        return append(i);
+                    }
+                    case 1: {
+                        return done(i);
+                    }
+                }
+            }
+            case 5: {
+                const i = i5([node[1], node[3]]);
+                switch (i) {
+                    case 0:
+                    case 2:
+                    case 4: {
+                        return append(i);
+                    }
+                    case 1:
+                    case 3: {
+                        return done(i);
+                    }
+                }
+            }
+        }
+    };
+    return f(null);
+};
+/** @type {<T>(first: First<T>) => boolean} */
+export const isFound = ([i]) => {
+    switch (i) {
+        case 1:
+        case 3: {
+            return true;
+        }
+        default: {
+            return false;
+        }
+    }
+};
+/** @type {<T>(first: First<T>) => T | null} */
+export const value = ([i, r]) => {
+    switch (i) {
+        case 1: {
+            switch (r.length) {
+                case 1:
+                case 2: {
+                    return r[0];
+                }
+                default: {
+                    return r[1];
+                }
+            }
+        }
+        case 3: {
+            return r.length === 2 ? r[1] : r[3];
+        }
+        default: {
+            return null;
+        }
+    }
+};

package/out/types/btree/find/test.f.mjs

@@ -0,0 +1,156 @@
+import * as _ from './module.f.mjs';
+import * as list from '../../list/module.f.mjs';
+import * as json from '../../../json/module.f.mjs';
+import * as o from '../../object/module.f.mjs';
+const { sort } = o;
+import * as btree from '../types/module.f.mjs';
+import * as string from '../../string/module.f.mjs';
+const { cmp } = string;
+import * as s from '../set/module.f.mjs';
+const jsonStr = json.stringify(sort);
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+const set = node => value => s.set(cmp(value))(() => value)(node);
+/** @type {(r: _.Result<json.Unknown>) => string} */
+const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)));
+/** @type {(i: string) => (m: btree.Node<string>) => string} */
+const find = i => m => str(_.find(cmp(i))(m));
+const test = () => {
+    /** @type {btree.Node<string>} */
+    let _map = ['1'];
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString());
+    {
+        const s = jsonStr(_map);
+        if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {
+            throw s;
+        }
+    }
+    //
+    {
+        const r = find("0")(_map);
+        if (r !== '[0,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("1")(_map);
+        if (r !== '[1,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("10")(_map);
+        if (r !== '[2,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("100")(_map);
+        if (r !== '[3,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("12")(_map);
+        if (r !== '[4,0,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("16")(_map);
+        if (r !== '[1,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("17")(_map);
+        if (r !== '[0,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("25")(_map);
+        if (r !== '[1,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("26")(_map);
+        if (r !== '[2,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("36")(_map);
+        if (r !== '[3,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("37")(_map);
+        if (r !== '[4,2,0]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("4")(_map);
+        if (r !== '[1]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("41")(_map);
+        if (r !== '[0,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("49")(_map);
+        if (r !== '[1,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("5")(_map);
+        if (r !== '[2,0,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("64")(_map);
+        if (r !== '[1,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("65")(_map);
+        if (r !== '[0,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("81")(_map);
+        if (r !== '[1,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("85")(_map);
+        if (r !== '[2,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("9")(_map);
+        if (r !== '[3,2,2]') {
+            throw r;
+        }
+    }
+    {
+        const r = find("91")(_map);
+        if (r !== '[4,2,2]') {
+            throw r;
+        }
+    }
+};
+export default test;

package/out/types/btree/module.f.d.mts

@@ -0,0 +1,5 @@
+export const empty: null;
+/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
+export const values: <T>(tree: _.Tree<T>) => list.List<T>;
+import * as _ from './types/module.f.mjs';
+import * as list from '../list/module.f.mjs';

package/out/types/btree/module.f.mjs

@@ -0,0 +1,34 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../list/module.f.mjs';
+const { flat } = list;
+import * as n from '../nullable/module.f.mjs';
+const { map } = n;
+import * as _ from './types/module.f.mjs';
+/** @type {<T>(node: _.Node<T>) => list.Thunk<T>} */
+const nodeValues = node => () => {
+    switch (node.length) {
+        case 1:
+        case 2: {
+            return node;
+        }
+        case 3: {
+            return flat([
+                nodeValues(node[0]),
+                [node[1]],
+                nodeValues(node[2])
+            ]);
+        }
+        default: {
+            return flat([
+                nodeValues(node[0]),
+                [node[1]],
+                nodeValues(node[2]),
+                [node[3]],
+                nodeValues(node[4])
+            ]);
+        }
+    }
+};
+export const empty = null;
+/** @type {<T>(tree: _.Tree<T>) => list.List<T>} */
+export const values = map(nodeValues);

package/{types → out/types}/btree/remove/module.f.d.mts

@@ -1,19 +1,14 @@
-declare namespace _default {
-    export { nodeRemove };
-    export { remove };
-}
-export default _default;
+/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
+export const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
+/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
+export const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
 export type Leaf01<T> = null | _.Leaf1<T>;
 export type RemovePath<T> = {
     readonly first: Leaf01<T>;
-    readonly tail: Find.Path<T>;
+    readonly tail: find.Path<T>;
 };
 export type Branch<T> = _.Branch1<T> | _.Branch3<T> | _.Branch5<T>;
 export type Merge<A, T> = (a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>;
-/** @type {<T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>} */
-declare const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.Node<T>) => _.Tree<T>;
-/** @type {<T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>} */
-declare const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
-import * as _ from '../types/module.f.mjs';
-import * as Find from '../find/module.f.mjs';
 import * as Cmp from '../../function/compare/module.f.mjs';
+import * as _ from '../types/module.f.mjs';
+import * as find from '../find/module.f.mjs';