functionalscript 0.2.0 → 0.2.1

package/out/text/utf8/test.f.mjs

@@ -0,0 +1,175 @@
+import * as encoding from './module.f.mjs';
+import * as json from '../../json/module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { sort } = o;
+import * as list from '../../types/list/module.f.mjs';
+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/out/types/array/module.f.mjs

@@ -0,0 +1,95 @@
+// @ts-self-types="./module.f.d.mts"
+import * as option from '../nullable/module.f.mjs';
+const { map } = option;
+/**
+ * @template T
+ * @typedef {readonly[T]} Array1
+ */
+/** @typedef {0} Index1 */
+/**
+ * @template T
+ * @typedef {readonly[T, T]} Array2
+ */
+/**
+ * @template T0
+ * @template T1
+ * @typedef {readonly[T0, T1]} Tuple2
+ */
+/** @typedef {0|1} Index2 */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T]} Array3
+ */
+/**
+ * @template T0
+ * @template T1
+ * @template T2
+ * @typedef {readonly[T0, T1, T2]} Tuple3
+ */
+/** @typedef {0|1|2} Index3 */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T]} Array4
+ */
+/** @typedef {0|1|2|3} Index4 */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T, T]} Array5
+ */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T, T, T, T, T]} Array8
+ */
+/**
+ * @template T
+ * @typedef {readonly[T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T]} Array16
+ */
+/** @typedef {0|1|2|3|4|5|6|7|8|9|10|11|12|13|14|15} Index16 */
+/**
+ * @template T
+ * @typedef {Array1<T>| Array2<T> | Array3<T> | Array4<T> | Array5<T>} Array1_5
+ */
+/** @typedef {0|1|2|3|4} Index5 */
+/**
+ * @template T
+ * @typedef {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
+ * } KeyOf
+ */
+/** @type {<T>(_: readonly T[]) => readonly T[]} */
+const uncheckTail = a => a.slice(1);
+/** @type {<T>(_: readonly T[]) => readonly T[]} */
+const uncheckHead = a => a.slice(0, -1);
+/** @type {(index: number) => <T>(a: readonly T[]) => T|null} */
+export const at = i => a => {
+    const r = a[i];
+    return r === void 0 ? null : r;
+};
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const first = at(0);
+/** @type {<T>(_: readonly T[]) => T|null} */
+export const last = a => at(a.length - 1)(a);
+/** @type {<T>(_: readonly T[]) => readonly T[] | null} */
+export const tail = a => a.length === 0 ? null : uncheckTail(a);
+/** @type {<T>(_: readonly T[]) => readonly[T, readonly T[]]|null} */
+export const splitFirst = a => {
+    /** @typedef {typeof a[0]} T*/
+    /** @type {(_: T) => readonly[T, readonly T[]]} */
+    const split = first => [first, uncheckTail(a)];
+    return map(split)(first(a));
+};
+/** @type {<T>(_: readonly T[]) => readonly T[]|null} */
+export const head = a => a.length === 0 ? null : uncheckHead(a);
+/** @type {<T>(_: readonly T[]) => readonly[readonly T[], T]|null} */
+export const splitLast = a => {
+    const lastA = last(a);
+    if (lastA === null) {
+        return null;
+    }
+    return [uncheckHead(a), lastA];
+};

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

@@ -0,0 +1,116 @@
+import * as _ from './module.f.mjs';
+import * as json from '../../json/module.f.mjs';
+import * as o from '../object/module.f.mjs';
+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/out/types/bigfloat/module.f.mjs

@@ -0,0 +1,77 @@
+// @ts-self-types="./module.f.d.mts"
+import * as bi from '../bigint/module.f.mjs';
+const { abs, sign } = bi;
+/** @typedef {readonly[bigint,number]} BigFloat */
+/** @typedef {readonly[BigFloat,bigint]} BigFloatWithRemainder */
+const twoPow53 = 9007199254740992n;
+const twoPow54 = 18014398509481984n;
+/** @type {(value: BigFloat) => (min: bigint) => BigFloat} */
+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--;
+    }
+};
+/** @type {(value: BigFloat) => (max: bigint) => BigFloat} */
+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++;
+    }
+};
+/** @type {(base: bigint) => (exp: number) => bigint} */
+const pow = base => exp => base ** BigInt(exp);
+const pow5 = pow(5n);
+/** @type {(b: BigFloat) => (mul: bigint) => BigFloat} */
+export const multiply = ([m, e]) => mul => [m * mul, e];
+/** @type {(b: BigFloat) => (div: bigint) => BigFloatWithRemainder} */
+const divide = ([m, e]) => div => [[m / div, e], m % div];
+/** @type {(b: BigFloatWithRemainder) => BigFloat} */
+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);
+};
+/** @type {(dec: BigFloat) => BigFloat} */
+export const decToBin = dec => {
+    if (dec[0] === 0n) {
+        return [0n, 0];
+    }
+    if (dec[1] >= 0) {
+        /** @type {BigFloat} */
+        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);
+};