functionalscript 0.8.0 → 0.8.2

package/types/bit_vec/test.f.js

@@ -1,7 +1,27 @@
-import { empty, vec, length, uint, lsb, msb } from "./module.f.js";
+import { abs, mask } from "../bigint/module.f.js";
+import { asBase, asNominal } from "../nominal/module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8 } from "./module.f.js";
+const unsafeVec = (a) => asNominal(a);
+// 0x8 = 0b1000 = 0 + 8
+// 0x9 = 0b1001 = 1 + 8
+// 0xA = 0b1010 = 2 + 8
+// 0xB = 0b1011 = 3 + 8
+// 0xC = 0b1100 = 4 + 8
+// 0xD = 0b1101 = 5 + 8
+// 0xE = 0b1110 = 6 + 8
+// 0xF = 0b1111 = 7 + 8
+const assertEq = (a, b) => {
+    if (a !== b) {
+        throw [a, b];
+    }
+};
+const assertEq2 = ([a0, a1], [b0, b1]) => {
+    assertEq(a0, b0);
+    assertEq(a1, b1);
+};
 const frontTest = (e) => (r0) => (r1) => () => {
-    const vector = vec(8n)(0xf5n); // 0x1F5n
-    if (vector !== 0x1f5n) {
+    const vector = vec(8n)(0xf5n); // 0xF5n
+    if (vector !== unsafeVec(0xf5n)) {
         throw vector;
     }
     const result = e.front(4n)(vector);
@@ -14,25 +34,25 @@ const frontTest = (e) => (r0) => (r1) => () => {
     }
 };
 const popFront = (e) => ([r00, r01]) => ([r10, r11]) => () => {
-    const vector = vec(8n)(0xf5n); // 0x1F5n
+    const vector = vec(8n)(0xf5n); // 0xF5n
     const [result, rest] = e.popFront(4n)(vector);
     if (result !== r00) {
         throw result;
     }
-    if (rest !== r01) {
+    if (rest !== unsafeVec(r01)) {
         throw rest;
     }
     const [result2, rest2] = e.popFront(16n)(vector);
     if (result2 !== r10) {
         throw result2;
     }
-    if (rest2 !== r11) {
+    if (rest2 !== unsafeVec(r11)) {
         throw rest2;
     }
 };
 const removeFront = (e) => (r0) => (r1) => () => {
-    const v = vec(16n)(0x3456n); // 0x13456n
-    if (v !== 0x13456n) {
+    const v = vec(16n)(0x3456n); // -0xB456n
+    if (v !== unsafeVec(-0xb456n)) {
         throw v;
     }
     const r = e.removeFront(4n)(v);
@@ -46,44 +66,35 @@ const removeFront = (e) => (r0) => (r1) => () => {
 };
 const concat = (e) => (r) => () => {
     const u8 = vec(8n);
-    const a = u8(0x45n); // 0x145n
-    if (a !== 0x145n) {
+    const a = u8(0x45n); // -0xC5n
+    if (a !== unsafeVec(-0xc5n)) {
         throw a;
     }
-    const b = u8(0x89n); // 0x189n
-    if (b !== 0x189n) {
+    const b = u8(0x89n); // 0x89n
+    if (b !== unsafeVec(0x89n)) {
         throw b;
     }
-    const ab = e.concat(a)(b); // 0x18945n
+    const ab = e.concat(a)(b); // 0x8945n
     if (ab !== r) {
         throw ab;
     }
 };
-const assertEq = (a, b) => {
-    if (a !== b) {
-        throw [a, b];
-    }
-};
-const assertEq2 = ([a0, a1], [b0, b1]) => {
-    assertEq(a0, b0);
-    assertEq(a1, b1);
-};
 export default {
     examples: {
         vec: () => {
             const vec4 = vec(4n);
-            const v0 = vec4(5n); // 0x15n
-            if (v0 !== 0x15n) {
+            const v0 = vec4(5n); // 0b0101 => -0b1101
+            if (v0 !== unsafeVec(-0xdn)) {
                 throw v0;
             }
-            const v1 = vec4(0x5fen); // 0x1En
-            if (v1 !== 0x1en) {
+            const v1 = vec4(0x5fen); // 0xEn
+            if (v1 !== unsafeVec(0xen)) {
                 throw v1;
             }
         },
         uint: () => {
-            const vector = vec(8n)(0x5n); // 0x105n
-            if (vector !== 0x105n) {
+            const vector = vec(8n)(0x5n); // -0x85n
+            if (vector !== unsafeVec(-0x85n)) {
                 throw vector;
             }
             const result = uint(vector); // result is 0x5n
@@ -92,32 +103,32 @@ export default {
             }
         },
         front: () => {
-            const vector = vec(8n)(0xf5n); // 0x1F5n
+            const vector = vec(8n)(0xf5n); // 0xF5n
             assertEq(lsb.front(4n)(vector), 5n);
             assertEq(lsb.front(16n)(vector), 0xf5n);
             assertEq(msb.front(4n)(vector), 0xfn);
             assertEq(msb.front(16n)(vector), 0xf500n);
         },
         removeFront: () => {
-            const v = vec(16n)(0x3456n); // 0x13456n
-            assertEq(lsb.removeFront(4n)(v), 0x1345n);
-            assertEq(lsb.removeFront(24n)(v), 0x1n);
-            assertEq(msb.removeFront(4n)(v), 0x1456n);
-            assertEq(msb.removeFront(24n)(v), 0x1n);
+            const v = vec(16n)(0x3456n); // -0xB456n
+            assertEq(lsb.removeFront(4n)(v), asNominal(-0xb45n));
+            assertEq(lsb.removeFront(24n)(v), empty);
+            assertEq(msb.removeFront(4n)(v), asNominal(-0xc56n));
+            assertEq(msb.removeFront(24n)(v), empty);
         },
         popFront: () => {
-            const vector = vec(8n)(0xf5n); // 0x1F5n
-            assertEq2(lsb.popFront(4n)(vector), [5n, 0x1fn]);
-            assertEq2(lsb.popFront(16n)(vector), [0xf5n, 1n]);
-            assertEq2(msb.popFront(4n)(vector), [0xfn, 0x15n]);
-            assertEq2(msb.popFront(16n)(vector), [0xf500n, 1n]);
+            const vector = vec(8n)(0xf5n); // 0xF5n
+            assertEq2(lsb.popFront(4n)(vector), [5n, asNominal(0xfn)]);
+            assertEq2(lsb.popFront(16n)(vector), [0xf5n, empty]);
+            assertEq2(msb.popFront(4n)(vector), [0xfn, asNominal(-0xdn)]);
+            assertEq2(msb.popFront(16n)(vector), [0xf500n, empty]);
         },
         concat: () => {
             const u8 = vec(8n);
-            const a = u8(0x45n); // 0x145n
-            const b = u8(0x89n); // 0x189n
-            assertEq(lsb.concat(a)(b), 0x18945n);
-            assertEq(msb.concat(a)(b), 0x14589n);
+            const a = u8(0x45n); // -0xC5n
+            const b = u8(0x89n); // 0x89n
+            assertEq(lsb.concat(a)(b), asNominal(0x8945n));
+            assertEq(msb.concat(a)(b), asNominal(-0xc589n));
         }
     },
     front: {
@@ -125,19 +136,19 @@ export default {
         msbf: frontTest(msb)(0xfn)(0xf500n),
     },
     popFront: {
-        lsbm: popFront(lsb)([5n, 0x1fn])([0xf5n, 1n]),
-        msbm: popFront(msb)([0xfn, 0x15n])([0xf500n, 1n]),
+        lsbm: popFront(lsb)([5n, 0xfn])([0xf5n, 0n]),
+        msbm: popFront(msb)([0xfn, -0xdn])([0xf500n, 0n]),
     },
     removeFront: {
-        lsbm: removeFront(lsb)(0x1345n)(0x1n),
-        msbm: removeFront(msb)(0x1456n)(0x1n),
+        lsbm: removeFront(lsb)(asNominal(-0xb45n))(empty),
+        msbm: removeFront(msb)(asNominal(-0xc56n))(empty),
     },
     concat: {
-        lsbm: concat(lsb)(0x18945n),
-        msbm: concat(msb)(0x14589n),
+        lsbm: concat(lsb)(asNominal(0x8945n)),
+        msbm: concat(msb)(asNominal(-0xc589n)),
     },
     uintLsb: () => {
-        const vector = 117n;
+        const vector = asNominal(53n);
         const extract3Bits = lsb.front(3n);
         const result = extract3Bits(vector); // result is 0b101n (5n)
         if (result !== 5n) {
@@ -145,7 +156,7 @@ export default {
         }
     },
     uintSmall: () => {
-        const vector = 3n;
+        const vector = asNominal(1n);
         const extract3Bits = lsb.front(3n)(vector);
         if (extract3Bits !== 1n) {
             throw extract3Bits;
@@ -153,20 +164,20 @@ export default {
     },
     vecExample: () => {
         const createVector = vec(4n);
-        const vector = createVector(5n); // vector is 0b10101n
-        if (vector !== 21n) {
+        const vector = createVector(5n); // vector is -0b1101n
+        if (vector !== unsafeVec(-13n)) {
             throw vector;
         }
     },
     length: () => {
-        const i = length(empty);
-        if (i !== 0n) {
-            throw i;
+        const len = length(empty);
+        if (len !== 0n) {
+            throw len;
         }
     },
     bitset: () => {
         const v = vec(8n)(0x5fen);
-        if (v !== 0x1fen) {
+        if (v !== unsafeVec(0xfen)) {
             throw v;
         }
         if (length(v) !== 8n) {
@@ -182,7 +193,7 @@ export default {
         const a = vec8(0x345n);
         const b = vec8(0x789n);
         const ab = lsb.concat(a)(b);
-        if (ab !== 0x18945n) {
+        if (ab !== unsafeVec(0x8945n)) {
             throw ab;
         }
         const s = length(ab);
@@ -192,12 +203,222 @@ export default {
     },
     removeBack: () => {
         const v = vec(17n)(0x12345n);
-        if (v !== 0x32345n) {
-            throw v.toString(16);
+        if (v !== unsafeVec(0x12345n)) {
+            throw asBase(v).toString(16);
         }
         const r = lsb.removeFront(9n)(v);
-        if (r !== 0x191n) {
-            throw r.toString(16);
+        if (r !== unsafeVec(0x91n)) {
+            throw asBase(r).toString(16);
+        }
+    },
+    uint: [
+        // 0
+        () => {
+            const x = uint(asNominal(0n));
+            if (x !== 0n) {
+                throw x;
+            }
+        },
+        // 1
+        () => {
+            const v = asNominal(1n);
+            const x = uint(v);
+            if (x !== 1n) {
+                throw x;
+            }
+            const len = length(v);
+            if (len !== 1n) {
+                throw len;
+            }
+        },
+        // 2
+        () => {
+            const v = asNominal(2n);
+            const x = uint(v);
+            if (x !== 2n) {
+                throw x;
+            }
+            const len = length(v);
+            if (len !== 2n) {
+                throw len;
+            }
+        },
+        // 3
+        () => {
+            const v = asNominal(3n);
+            const x = uint(v);
+            if (x !== 3n) {
+                throw x;
+            }
+            const len = length(v);
+            if (len !== 2n) {
+                throw len;
+            }
+        },
+        // 4
+        () => {
+            const v = asNominal(-1n);
+            const x = uint(v);
+            if (x !== 0n) {
+                throw x;
+            }
+            const len = length(v);
+            if (len !== 1n) {
+                throw len;
+            }
+        },
+        () => {
+            const v = asNominal(-2n);
+            const x = uint(v);
+            if (x !== 0n) {
+                throw x;
+            }
+            const len = length(v);
+            if (len !== 2n) {
+                throw len;
+            }
+        },
+        () => {
+            const v = asNominal(-3n);
+            const x = uint(v);
+            if (x !== 1n) {
+                throw x;
+            }
+            const len = length(v);
+            if (len !== 2n) {
+                throw len;
+            }
+        }
+    ],
+    vec: [
+        // 0
+        () => {
+            const v = asBase(vec(0n)(0n));
+            if (v !== 0n) {
+                throw v;
+            }
+        },
+        () => {
+            const v = asBase(vec(0n)(1n));
+            if (v !== 0n) {
+                throw v;
+            }
+        },
+        () => {
+            const v = asBase(vec(0n)(-1n));
+            if (v !== 0n) {
+                throw v;
+            }
+        },
+        // 1
+        () => {
+            const v = asBase(vec(1n)(0n));
+            if (v !== -1n) {
+                throw v;
+            }
+        },
+        () => {
+            const v = asBase(vec(1n)(1n));
+            if (v !== 1n) {
+                throw v;
+            }
+        },
+        () => {
+            const v = asBase(vec(1n)(-1n));
+            if (v !== 1n) {
+                throw v;
+            }
+        },
+        () => {
+            const v = asBase(vec(1n)(2n));
+            if (v !== -1n) {
+                throw v;
+            }
+        },
+        () => {
+            const v = asBase(vec(1n)(3n));
+            if (v !== 1n) {
+                throw v;
+            }
+        }
+    ],
+    both: () => {
+        const c = (len) => (ui) => (raw) => {
+            const v = vec(len)(ui);
+            const x = asBase(v);
+            if (x !== raw) {
+                throw x;
+            }
+            const len2 = length(v);
+            if (len2 !== len) {
+                throw len2;
+            }
+            const u = uint(v);
+            const mui = mask(len) & abs(ui);
+            if (u !== mui) {
+                throw u;
+            }
+        };
+        // 0n
+        for (const i of [0n, 1n, -1n, 2n, -2n, 3n, -3n]) {
+            c(0n)(i)(0n);
+        }
+        return [
+            // 1n
+            () => c(1n)(0n)(-1n),
+            () => c(1n)(1n)(1n),
+            () => c(1n)(-11n)(1n), //< overflow
+            // 2n
+            () => c(2n)(0n)(-2n),
+            () => c(2n)(1n)(-3n),
+            () => c(2n)(2n)(2n),
+            () => c(2n)(3n)(3n),
+            () => c(2n)(-7n)(3n), //< overflow
+        ];
+    },
+    concat2: () => {
+        const c = (a) => (b) => (abx) => {
+            const ab = msb.concat(a)(b);
+            const abLen = length(ab);
+            const abxLen = length(abx);
+            if (abLen !== abxLen) {
+                throw abLen;
+            }
+            const abU = uint(ab);
+            const abxU = uint(abx);
+            if (abU !== abxU) {
+                throw abU;
+            }
+        };
+        c(vec(4n)(0xfn))(vec(8n)(0xa7n))(vec(12n)(0xfa7n));
+        c(vec(4n)(0xfn))(vec(8n)(0x57n))(vec(12n)(0xf57n));
+        c(vec(4n)(0x5n))(vec(8n)(0xa7n))(vec(12n)(0x5a7n));
+        c(vec(4n)(0x5n))(vec(8n)(0x79n))(vec(12n)(0x579n));
+    },
+    lsbXor: () => {
+        const c = (a) => (b) => (e) => {
+            const r = lsb.xor(a)(b);
+            if (r !== e) {
+                throw r;
+            }
+        };
+        c(vec(4n)(0x7n))(vec(8n)(0x12n))(vec(8n)(0x7n ^ 0x12n));
+    },
+    msbXor: () => {
+        const c = (a) => (b) => (e) => {
+            const r = msb.xor(a)(b);
+            if (r !== e) {
+                throw r;
+            }
+        };
+        c(vec(4n)(0x7n))(vec(8n)(0x12n))(vec(8n)(0x70n ^ 0x12n));
+    },
+    repeat: () => {
+        if (repeat(4n)(vec8(0xa5n)) !== vec(32n)(0xa5a5a5a5n)) {
+            throw 'repeat failed';
+        }
+        if (repeat(7n)(vec(5n)(0x13n)) !== vec(35n)(21059194483n)) {
+            throw 'repeat failed';
         }
     }
 };

package/types/btree/find/test.f.js

@@ -1,13 +1,14 @@
-import * as _ from "./module.f.js";
-import * as list from "../../list/module.f.js";
-import * as json from "../../../json/module.f.js";
+import { find as btreeFind } from "./module.f.js";
+import { map, toArray } from "../../list/module.f.js";
+import { stringify } from "../../../json/module.f.js";
 import { sort } from "../../object/module.f.js";
+import {} from "../types/module.f.js";
 import { cmp } from "../../string/module.f.js";
-import * as s from "../set/module.f.js";
-const jsonStr = json.stringify(sort);
-const set = node => value => s.set(cmp(value))(() => value)(node);
-const str = r => jsonStr(list.toArray(list.map((x) => x[0])(r)));
-const find = i => m => str(_.find(cmp(i))(m));
+import { set as setSet } from "../set/module.f.js";
+const jsonStr = stringify(sort);
+const set = node => value => setSet(cmp(value))(() => value)(node);
+const str = r => jsonStr(toArray(map((x) => x[0])(r)));
+const find = i => m => str(btreeFind(cmp(i))(m));
 const test = () => {
     let _map = ['1'];
     for (let i = 2; i <= 10; i++) {

package/types/btree/remove/test.f.js

@@ -1,11 +1,11 @@
 import { nodeRemove } from "./module.f.js";
-import * as s from "../set/module.f.js";
+import { set as setSet } from "../set/module.f.js";
 import { cmp } from "../../string/module.f.js";
-import * as json from "../../../json/module.f.js";
+import { stringify } from "../../../json/module.f.js";
 import { sort } from "../../object/module.f.js";
-const set = (node) => (value) => s.set(cmp(value))(() => value)(node);
+const set = (node) => (value) => setSet(cmp(value))(() => value)(node);
 const remove = (node) => (value) => nodeRemove(cmp(value))(node);
-const jsonStr = json.stringify(sort);
+const jsonStr = stringify(sort);
 const test = () => {
     let _map = ['1'];
     for (let i = 2; i <= 38; i++)

package/types/btree/set/test.f.js

@@ -1,9 +1,9 @@
-import * as _ from "./module.f.js";
+import { set as setSet } from "./module.f.js";
 import { cmp } from "../../string/module.f.js";
-import * as json from "../../../json/module.f.js";
+import { stringify } from "../../../json/module.f.js";
 import { sort } from "../../object/module.f.js";
-const set = (node) => (value) => _.set(cmp(value))(() => value)(node);
-const jsonStr = json.stringify(sort);
+const set = (node) => (value) => setSet(cmp(value))(() => value)(node);
+const jsonStr = stringify(sort);
 const test = [
     () => {
         let _map = ['1'];

package/types/btree/test.f.js

@@ -1,13 +1,13 @@
 import { values } from "./module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 import { cmp } from "../string/module.f.js";
 import { next, toArray } from "../list/module.f.js";
-import * as s from "./set/module.f.js";
-import * as f from "./find/module.f.js";
-const jsonStr = json.stringify(sort);
+import { set as setSet } from "./set/module.f.js";
+import { value, find as findFind } from "./find/module.f.js";
+const jsonStr = jsonStringify(sort);
 const stringify = sequence => jsonStr(toArray(sequence));
-const set = node => value => s.set(cmp(value))(() => value)(node);
+const set = node => value => setSet(cmp(value))(() => value)(node);
 const valueTest1 = () => {
     let _map = ['a'];
     _map = set(_map)('b');
@@ -33,7 +33,7 @@ const findTrue = () => {
     let _map = ['a'];
     _map = set(_map)('b');
     _map = set(_map)('c');
-    const result = f.value(f.find(cmp('b'))(_map).first);
+    const result = value(findFind(cmp('b'))(_map).first);
     if (result !== 'b') {
         throw result;
     }
@@ -42,7 +42,7 @@ const find = () => {
     let _map = ['a'];
     _map = set(_map)('b');
     _map = set(_map)('c');
-    const result = f.value(f.find(cmp('e'))(_map).first);
+    const result = value(findFind(cmp('e'))(_map).first);
     if (result !== null) {
         throw result;
     }

package/types/byte_set/test.f.js

@@ -1,8 +1,8 @@
 import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from "./module.f.js";
 import { every, countdown, map, toArray } from "../list/module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
-const stringify = json.stringify(sort);
+const stringify = jsonStringify(sort);
 export default {
     has: [
         () => {

package/types/function/compare/module.f.d.ts

@@ -3,4 +3,18 @@ export type Sign = -1 | 0 | 1;
 export type Compare<T> = (_: T) => Sign;
 export declare const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
 export declare const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
-export declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
+export type Cmp1 = boolean | string | number | bigint;
+export type Cmp2<A, B> = [
+    A,
+    B
+] extends [boolean, boolean] ? boolean : [
+    A,
+    B
+] extends [string, string] ? string : [
+    A,
+    B
+] extends [number, number] ? number : [
+    A,
+    B
+] extends [bigint, bigint] ? bigint : never;
+export declare const cmp: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => Sign;

package/types/function/compare/module.f.js

@@ -3,4 +3,4 @@ export const index5 = cmp => ([v0, v1]) => {
     const _0 = cmp(v0);
     return (_0 <= 0 ? _0 + 1 : cmp(v1) + 3);
 };
-export const unsafeCmp = a => b => a < b ? -1 : a > b ? 1 : 0;
+export const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;

package/types/function/compare/test.f.js

@@ -1,7 +1,40 @@
-import { unsafeCmp } from "./module.f.js";
+import { cmp } from "./module.f.js";
 export default () => {
-    const result = unsafeCmp(true)(false);
-    if (result !== 1) {
-        throw result;
+    {
+        const result = cmp(true)(false);
+        if (result !== 1) {
+            throw result;
+        }
+        const _ = true < false;
+    }
+    {
+        const result = cmp(1)(2);
+        if (result !== -1) {
+            throw result;
+        }
+        const _ = 1 < 2;
+    }
+    {
+        const result = cmp(2n)(-10n);
+        if (result !== 1) {
+            throw result;
+        }
+        const _ = 2n < -10n;
+    }
+    {
+        const result = cmp("hello")("hello");
+        if (result !== 0) {
+            throw result;
+        }
+        const _ = "hello" < "hello";
+    }
+    {
+        // const result = cmp(true)("hello") // compilation error
+        const a = "hello";
+        const b = 5;
+        // const _ = cmp(a)(b) // compilation error
+        const _ = cmp(a)("hello"); // ??? TypeScript changes a type definition of `a`.
+        // const f = (a: string|number, b: string|number) => cmp(a)(b) // compilation error
+        // const f = (a: number, b: string|number) => cmp(a)(b) // compilation error
     }
 };