functionalscript 0.3.4 → 0.3.5

package/text/utf16/test.f.js

@@ -0,0 +1,144 @@
+import * as encoding from "./module.f.js";
+import * as json from "../../json/module.f.js";
+import * as o from "../../types/object/module.f.js";
+const { sort } = o;
+import * as list from "../../types/list/module.f.js";
+const stringify = a => json.stringify(sort)(a);
+export default {
+    toCodePointList: [
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([-1, 65536])));
+            if (result !== '[4294967295,4294967295]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([0, 36, 8364, 55295, 57344, 65535])));
+            if (result !== '[0,36,8364,55295,57344,65535]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([56320, 57343])));
+            if (result !== '[-2147427328,-2147426305]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([55296, 56320, 55297, 56375, 55378, 57186, 56319, 57343])));
+            if (result !== '[65536,66615,150370,1114111]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([55296, 55296])));
+            if (result !== '[-2147428352,-2147428352]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([55296, 0])));
+            if (result !== '[-2147428352,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([56320])));
+            if (result !== '[-2147427328]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([56320, 0])));
+            if (result !== '[-2147427328,0]') {
+                throw result;
+            }
+        }
+    ],
+    fromCodePointList: [
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0])));
+            if (result !== '[0]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x24])));
+            if (result !== '[36]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x20AC])));
+            if (result !== '[8364]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xd7ff])));
+            if (result !== '[55295]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xe000])));
+            if (result !== '[57344]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])));
+            if (result !== '[65535]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])));
+            if (result !== '[55296,56320]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10437])));
+            if (result !== '[55297,56375]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x24B62])));
+            if (result !== '[55378,57186]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10ffff])));
+            if (result !== '[56319,57343]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([-1, 0xd800, 0xdfff, 0x110000])));
+            if (result !== '[65535,55296,57343,0]') {
+                throw result;
+            }
+        }
+    ],
+    string: [
+        () => {
+            const utf16List = encoding.stringToList("Hello world!😂🚜🚲");
+            const result = encoding.listToString(utf16List);
+            if (result !== "Hello world!😂🚜🚲") {
+                throw result;
+            }
+        },
+        () => {
+            const a = encoding.stringToList("Hello world!😂🚜🚲");
+            const b = encoding.toCodePointList(a);
+            const c = encoding.fromCodePointList(b);
+            const result = encoding.listToString(c);
+            if (result !== "Hello world!😂🚜🚲") {
+                throw result;
+            }
+        }
+    ]
+};

package/text/utf8/module.f.d.ts

@@ -0,0 +1,6 @@
+import { type List, type Thunk } from '../../types/list/module.f.ts';
+type u8 = number;
+type i32 = number;
+export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
+export declare const toCodePointList: (input: List<u8>) => List<i32>;
+export {};

package/text/utf8/module.f.js

@@ -0,0 +1,112 @@
+import { flatMap, flat, stateScan } from "../../types/list/module.f.js";
+import * as operator from "../../types/function/operator/module.f.js";
+import * as Array from "../../types/array/module.f.js";
+const errorMask = 0b1000_0000_0000_0000_0000_0000_0000_0000;
+const codePointToUtf8 = input => {
+    if (input >= 0x0000 && input <= 0x007f) {
+        return [input & 0b01111_1111];
+    }
+    if (input >= 0x0080 && input <= 0x07ff) {
+        return [input >> 6 | 0b1100_0000, input & 0b0011_1111 | 0b1000_0000];
+    }
+    if (input >= 0x0800 && input <= 0xffff) {
+        return [input >> 12 | 0b1110_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000];
+    }
+    if (input >= 0x10000 && input <= 0x10ffff) {
+        return [input >> 18 | 0b1111_0000, input >> 12 & 0b0011_1111 | 0b1000_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000];
+    }
+    if ((input & errorMask) !== 0) {
+        if ((input & 0b1000_0000_0000_0000) !== 0) {
+            return [input >> 12 & 0b0000_0111 | 0b1111_0000, input >> 6 & 0b0011_1111 | 0b1000_0000, input & 0b0011_1111 | 0b1000_0000];
+        }
+        if ((input & 0b0000_0100_0000_0000) !== 0) {
+            return [input >> 6 & 0b0000_1111 | 0b1110_0000, input & 0b0011_1111 | 0b1000_0000];
+        }
+        if ((input & 0b0000_0010_0000_0000) !== 0) {
+            return [input >> 6 & 0b0000_0111 | 0b1111_0000, input & 0b0011_1111 | 0b1000_0000];
+        }
+        if ((input & 0b0000_0000_1000_0000) !== 0) {
+            return [input & 0b1111_1111];
+        }
+    }
+    return [errorMask];
+};
+export const fromCodePointList = flatMap(codePointToUtf8);
+const utf8StateToError = state => {
+    let x;
+    switch (state.length) {
+        case 1: {
+            [x] = state;
+            break;
+        }
+        case 2: {
+            const [s0, s1] = state;
+            x = s0 < 0b1111_0000
+                ? ((s0 & 0b0000_1111) << 6) + (s1 & 0b0011_1111) + 0b0000_0100_0000_0000
+                : ((s0 & 0b0000_0111) << 6) + (s1 & 0b0011_1111) + 0b0000_0010_0000_0000;
+            break;
+        }
+        case 3: {
+            const [s0, s1, s2] = state;
+            x = ((s0 & 0b0000_0111) << 12) + ((s1 & 0b0011_1111) << 6) + (s2 & 0b0011_1111) + 0b1000_0000_0000_0000;
+            break;
+        }
+        default:
+            throw 'invalid state';
+    }
+    return x | errorMask;
+};
+const utf8ByteToCodePointOp = state => byte => {
+    if (byte < 0x00 || byte > 0xff) {
+        return [[errorMask], state];
+    }
+    if (state === null) {
+        if (byte < 0b1000_0000) {
+            return [[byte], null];
+        }
+        if (byte >= 0b1100_0010 && byte <= 0b1111_0100) {
+            return [[], [byte]];
+        }
+        return [[byte | errorMask], null];
+    }
+    if (byte >= 0b1000_0000 && byte < 0b1100_0000) {
+        switch (state.length) {
+            case 1: {
+                const [s0] = state;
+                if (s0 < 0b1110_0000) {
+                    return [[((s0 & 0b0001_1111) << 6) + (byte & 0b0011_1111)], null];
+                }
+                if (s0 < 0b1111_1000) {
+                    return [[], [s0, byte]];
+                }
+                break;
+            }
+            case 2: {
+                const [s0, s1] = state;
+                if (s0 < 0b1111_0000) {
+                    return [[((s0 & 0b0000_1111) << 12) + ((s1 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null];
+                }
+                if (s0 < 0b1111_1000) {
+                    return [[], [s0, s1, byte]];
+                }
+                break;
+            }
+            case 3: {
+                const [s0, s1, s2] = state;
+                return [[((s0 & 0b0000_0111) << 18) + ((s1 & 0b0011_1111) << 12) + ((s2 & 0b0011_1111) << 6) + (byte & 0b0011_1111)], null];
+            }
+        }
+    }
+    const error = utf8StateToError(state);
+    if (byte < 0b1000_0000) {
+        return [[error, byte], null];
+    }
+    if (byte >= 0b1100_0010 && byte <= 0b1111_0100) {
+        return [[error], [byte]];
+    }
+    return [[error, byte | errorMask], null];
+};
+const utf8EofToCodePointOp = state => [state === null ? null : [utf8StateToError(state)], null];
+const utf8ByteOrEofToCodePointOp = state => input => input === null ? utf8EofToCodePointOp(state) : utf8ByteToCodePointOp(state)(input);
+const eofList = [null];
+export const toCodePointList = input => flat(stateScan(utf8ByteOrEofToCodePointOp)(null)(flat([input, eofList])));

package/text/utf8/test.f.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    toCodePoint: (() => void)[];
+    fromCodePointList: (() => void)[];
+    toFrom: (() => void)[];
+};
+export default _default;

package/text/utf8/test.f.js

@@ -0,0 +1,175 @@
+import * as encoding from "./module.f.js";
+import * as json from "../../json/module.f.js";
+import * as o from "../../types/object/module.f.js";
+const { sort } = o;
+import * as list from "../../types/list/module.f.js";
+const stringify = json.stringify(sort);
+export default {
+    toCodePoint: [
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([-1, 256])));
+            if (result !== '[2147483648,2147483648]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([128, 193, 245, 255])));
+            if (result !== '[-2147483520,-2147483455,-2147483403,-2147483393]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([0, 1, 127])));
+            if (result !== '[0,1,127]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([194, 128, 194, 169, 223, 191])));
+            if (result !== '[128,169,2047]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([194, 194, 127, 194, 192, 194])));
+            if (result !== '[-2147483454,-2147483454,127,-2147483454,-2147483456,-2147483454]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])));
+            if (result !== '[2048,2049,65535]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([224, 224, 160, 127, 239, 191])));
+            if (result !== '[-2147483424,-2147482592,127,-2147481601]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])));
+            if (result !== '[65536,65537,1114111]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([240, 240, 160, 127, 244, 191])));
+            if (result !== '[-2147483408,-2147483104,127,-2147482817]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.toCodePointList([240, 160, 160, 244, 160, 160])));
+            if (result !== '[-2147448800,-2147432416]') {
+                throw result;
+            }
+        }
+    ],
+    fromCodePointList: [
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0, 1, 0x7F])));
+            if (result !== '[0,1,127]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x80])));
+            if (result !== '[194,128]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xa9])));
+            if (result !== '[194,169]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x7ff])));
+            if (result !== '[223,191]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x800])));
+            if (result !== '[224,160,128]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x801])));
+            if (result !== '[224,160,129]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])));
+            if (result !== '[239,191,191]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])));
+            if (result !== '[240,144,128,128]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10001])));
+            if (result !== '[240,144,128,129]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x10FFFF])));
+            if (result !== '[244,143,191,191]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(list.toArray(encoding.fromCodePointList([0x110000, 2147483648])));
+            if (result !== '[2147483648,2147483648]') {
+                throw result;
+            }
+        }
+    ],
+    toFrom: [
+        () => {
+            const codePointList = encoding.toCodePointList([128, 193, 245, 255]);
+            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            if (result !== '[128,193,245,255]') {
+                throw result;
+            }
+        },
+        () => {
+            const codePointList = encoding.toCodePointList([194, 194, 127, 194, 192, 194]);
+            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            if (result !== '[194,194,127,194,192,194]') {
+                throw result;
+            }
+        },
+        () => {
+            const codePointList = encoding.toCodePointList([224, 224, 160, 127, 239, 191]);
+            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            if (result !== '[224,224,160,127,239,191]') {
+                throw result;
+            }
+        },
+        () => {
+            const codePointList = encoding.toCodePointList([240, 240, 160, 127, 244, 191]);
+            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            if (result !== '[240,240,160,127,244,191]') {
+                throw result;
+            }
+        },
+        () => {
+            const codePointList = encoding.toCodePointList([240, 160, 160, 244, 160, 160]);
+            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            if (result !== '[240,160,160,244,160,160]') {
+                throw result;
+            }
+        }
+    ]
+};

package/types/array/module.f.d.ts

@@ -0,0 +1,21 @@
+export type Array1<T> = readonly [T];
+type Index1 = 0;
+export type Array2<T> = readonly [T, T];
+type Index2 = 0 | 1;
+export type Array3<T> = readonly [T, T, T];
+export type Index3 = 0 | 1 | 2;
+export type Array4<T> = readonly [T, T, T, T];
+type Index4 = 0 | 1 | 2 | 3;
+export type Array5<T> = readonly [T, T, T, T, T];
+export type Array8<T> = readonly [T, T, T, T, T, T, T, T];
+export type Array16<T> = readonly [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T];
+export type Index5 = 0 | 1 | 2 | 3 | 4;
+export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
+export declare const at: (index: number) => <T>(a: readonly T[]) => T | null;
+export declare const first: <T>(_: readonly T[]) => T | null;
+export declare const last: <T>(_: readonly T[]) => T | null;
+export declare const tail: <T>(_: readonly T[]) => readonly T[] | null;
+export declare const splitFirst: <T>(a: readonly T[]) => readonly [T, readonly T[]] | null;
+export declare const head: <T>(_: readonly T[]) => readonly T[] | null;
+export declare const splitLast: <T>(_: readonly T[]) => readonly [readonly T[], T] | null;
+export {};

package/types/array/module.f.js

@@ -0,0 +1,23 @@
+import * as option from "../nullable/module.f.js";
+const { map } = option;
+const uncheckTail = a => a.slice(1);
+const uncheckHead = a => a.slice(0, -1);
+export const at = i => a => {
+    const r = a[i];
+    return r === void 0 ? null : r;
+};
+export const first = at(0);
+export const last = a => at(a.length - 1)(a);
+export const tail = a => a.length === 0 ? null : uncheckTail(a);
+export const splitFirst = (a) => {
+    const split = first => [first, uncheckTail(a)];
+    return map(split)(first(a));
+};
+export const head = a => a.length === 0 ? null : uncheckHead(a);
+export const splitLast = a => {
+    const lastA = last(a);
+    if (lastA === null) {
+        return null;
+    }
+    return [uncheckHead(a), lastA];
+};

package/types/array/test.f.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    stringify: () => void;
+    at: (() => void)[];
+    first: (() => void)[];
+    last: (() => void)[];
+    head: (() => void)[];
+    tail: (() => void)[];
+    splitFirst: (() => void)[];
+};
+export default _default;

package/types/array/test.f.js

@@ -0,0 +1,116 @@
+import * as _ from "./module.f.js";
+import * as json from "../../json/module.f.js";
+import * as o from "../object/module.f.js";
+const { sort } = o;
+const stringify = json.stringify(sort);
+export default {
+    stringify: () => {
+        const result = stringify([1, 20, 300]);
+        if (result !== '[1,20,300]') {
+            throw result;
+        }
+    },
+    at: [
+        () => {
+            const result = _.at(2)([1, 20, 300]);
+            if (result !== 300) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.at(3)([1, 20, 300]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    first: [
+        () => {
+            const result = _.first([1, 20, 300]);
+            if (result !== 1) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.first([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    last: [
+        () => {
+            const result = _.last([1, 20, 300]);
+            if (result !== 300) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.last([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    head: [
+        () => {
+            const result = _.head([1, 20, 300]);
+            if (result === null) {
+                throw result;
+            }
+            const str = stringify(result);
+            if (str !== '[1,20]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.head([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    tail: [
+        () => {
+            const result = _.tail([1, 20, 300]);
+            const str = stringify(result);
+            if (str !== '[20,300]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.tail([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ],
+    splitFirst: [
+        () => {
+            const result = _.splitFirst([1, 20, 300]);
+            const str = stringify(result);
+            if (str !== '[1,[20,300]]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.splitFirst([]);
+            if (result !== null) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.splitLast([1, 20, 300]);
+            const str = stringify(result);
+            if (str !== '[[1,20],300]') {
+                throw str;
+            }
+        },
+        () => {
+            const result = _.splitLast([]);
+            if (result !== null) {
+                throw result;
+            }
+        }
+    ]
+};

package/types/bigfloat/module.f.d.ts

@@ -0,0 +1,3 @@
+export type BigFloat = readonly [bigint, number];
+export declare const multiply: (b: BigFloat) => (mul: bigint) => BigFloat;
+export declare const decToBin: (dec: BigFloat) => BigFloat;

package/types/bigfloat/module.f.js

@@ -0,0 +1,66 @@
+import * as bi from "../bigint/module.f.js";
+const { abs, sign } = bi;
+const twoPow53 = 9007199254740992n;
+const twoPow54 = 18014398509481984n;
+const increaseMantissa = ([m, e]) => min => {
+    if (m === 0n) {
+        return [m, e];
+    }
+    const s = sign(m);
+    m = abs(m);
+    while (true) {
+        if (m >= min) {
+            return [BigInt(s) * m, e];
+        }
+        m = m << 1n;
+        e--;
+    }
+};
+const decreaseMantissa = ([m, e]) => max => {
+    if (m === 0n) {
+        return [m, e];
+    }
+    const s = sign(m);
+    m = abs(m);
+    while (true) {
+        if (m < max) {
+            return [BigInt(s) * m, e];
+        }
+        m = m >> 1n;
+        e++;
+    }
+};
+const pow = base => exp => base ** BigInt(exp);
+const pow5 = pow(5n);
+export const multiply = ([m, e]) => mul => [m * mul, e];
+const divide = ([m, e]) => div => [[m / div, e], m % div];
+const round53 = ([[m, e], r]) => {
+    const mabs = abs(m);
+    const s = BigInt(sign(m));
+    const [m54, e54] = decreaseMantissa([mabs, e])(twoPow54);
+    const o54 = m54 & 1n;
+    const m53 = m54 >> 1n;
+    const e53 = e54 + 1;
+    if (o54 === 1n && r === 0n && mabs === m54 >> BigInt(e - e54)) {
+        const odd = m53 & 1n;
+        return multiply([m53 + odd, e53])(s);
+    }
+    return multiply([m53 + o54, e53])(s);
+};
+export const decToBin = dec => {
+    if (dec[0] === 0n) {
+        return [0n, 0];
+    }
+    if (dec[1] >= 0) {
+        const bin = [dec[0] * pow5(dec[1]), dec[1]];
+        const inc = increaseMantissa(bin)(twoPow53);
+        return round53([inc, 0n]);
+    }
+    const p = pow5(-dec[1]);
+    const [m, e] = increaseMantissa(dec)(p * twoPow53);
+    const mAbs = abs(m);
+    const s = BigInt(sign(m));
+    const qr = divide([mAbs, e])(p);
+    const r53 = round53(qr);
+    return multiply(r53)(s);
+};