functionalscript 0.1.609 → 0.2.1

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

@@ -0,0 +1,54 @@
+// @ts-self-types="./module.f.d.mts"
+import * as BtreeTypes from '../btree/types/module.f.mjs';
+import * as btf from '../btree/find/module.f.mjs';
+const { value, find } = btf;
+import * as bts from '../btree/set/module.f.mjs';
+const { set } = bts;
+import * as btr from '../btree/remove/module.f.mjs';
+const { remove: btreeRemove } = btr;
+import * as bt from '../btree/module.f.mjs';
+const { values } = bt;
+import * as Compare from '../function/compare/module.f.mjs';
+import * as s from '../string/module.f.mjs';
+const { cmp } = s;
+import * as list from '../list/module.f.mjs';
+const { fold } = list;
+import * as Operator from '../function/operator/module.f.mjs';
+/** @typedef {Compare.Sign} Sign */
+/**
+ * @template T
+ * @typedef {Compare.Compare<T>} Cmp
+ */
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+/**
+ * @template T
+ * @typedef {BtreeTypes.Tree<Entry<T>>} Map
+ */
+/** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
+const keyCmp = a => ([b]) => cmp(a)(b);
+/** @type {(name: string) => <T>(map: Map<T>) => T|null} */
+export const at = name => map => {
+    if (map === null) {
+        return null;
+    }
+    const result = value(find(keyCmp(name))(map).first);
+    return result === null ? null : result[1];
+};
+/** @type {<T>(reduce: Operator.Reduce<T>) => (entry: Entry<T>) => (map: Map<T>) => Map<T>} */
+const setReduceEntry = reduce => entry => set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])]);
+/** @type {<T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>} */
+export const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value]);
+/** @type {<T>(a: T) => (b: T) => T} */
+const replace = () => b => b;
+/** @type {(name: string) => <T>(value: T) => (map: Map<T>) => Map<T>} */
+export const setReplace = name => value => setReduceEntry(replace)([name, value]);
+/** @type {<T>(map: Map<T>) => list.List<Entry<T>>} */
+export const entries = values;
+/** @type {<T>(entries: list.List<Entry<T>>) => Map<T>} */
+export const fromEntries = fold(setReduceEntry(replace))(null);
+/** @type {(name: string) => <T>(map: Map<T>) => Map<T>} */
+export const remove = name => btreeRemove(keyCmp(name));
+export const empty = null;

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

@@ -0,0 +1,115 @@
+import * as _ from './module.f.mjs';
+const { at, setReplace, setReduce, empty, entries, remove } = _;
+import * as seq from '../list/module.f.mjs';
+export default {
+    main: [
+        () => {
+            let m = setReplace('a')(1)(null);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('b')(2)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('c')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('z')(3)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('z')(m) !== 3) {
+                throw 'error';
+            }
+            if (at('')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('')(4)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('z')(m) !== 3) {
+                throw 'error';
+            }
+            if (at('')(m) !== 4) {
+                throw 'error';
+            }
+            if (at('Hello world!')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('Hello world!')(42)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('z')(m) !== 3) {
+                throw 'error';
+            }
+            if (at('')(m) !== 4) {
+                throw 'error';
+            }
+            if (at('Hello world!')(m) !== 42) {
+                throw 'error';
+            }
+            if (at('x')(m) !== null) {
+                throw 'error';
+            }
+            // console.log(Array.from(m.entries()))
+            m = remove('Hello world!')(m);
+            if (at('Hello world!')(m) !== null) {
+                throw m;
+            }
+            m = setReduce(a => b => a + b)('a')(43)(m);
+            if (at('a')(m) !== 44) {
+                throw 'error';
+            }
+        },
+        () => {
+            let m = setReplace('x')(12)(null);
+            m = setReplace('y')(44)(m);
+            if (at('x')(m) !== 12) {
+                throw 'error';
+            }
+            if (at('y')(m) !== 44) {
+                throw 'error';
+            }
+            if (at('a')(m) !== null) {
+                throw 'error';
+            }
+            const e = seq.toArray(entries(m));
+            if (e.length !== 2) {
+                throw 'error';
+            }
+        },
+    ],
+    stress: () => {
+        /** @type {import('./module.f.mjs').Map<number>} */
+        let m = empty;
+        for (let i = 0; i < 100_000; ++i) {
+            m = setReplace((i * i).toString())(i)(m);
+            /*
+            console.log()
+            console.log(`# ${i}`)
+            console.log()
+            for (const e of m.struct()) {
+                console.log(e)
+            }
+            */
+        }
+    }
+};

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

@@ -0,0 +1,16 @@
+/** @typedef {number} NibbleSet */
+/** @typedef {number} Nibble */
+export const empty: 0;
+export const universe: 65535;
+/** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
+export const has: (n: Nibble) => (s: NibbleSet) => boolean;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+export const set: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+/** @type {(n: NibbleSet) => NibbleSet} */
+export const complement: (n: NibbleSet) => NibbleSet;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+export const unset: (n: Nibble) => (s: NibbleSet) => NibbleSet;
+/** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
+export const setRange: (r: readonly [number, number]) => (s: NibbleSet) => NibbleSet;
+export type NibbleSet = number;
+export type Nibble = number;

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

@@ -0,0 +1,19 @@
+// @ts-self-types="./module.f.d.mts"
+/** @typedef {number} NibbleSet */
+/** @typedef {number} Nibble */
+export const empty = 0;
+export const universe = 0xFFFF;
+/** @type {(n: Nibble) => NibbleSet} */
+const one = n => 1 << n;
+/** @type {(n: Nibble) => (s: NibbleSet) => boolean} */
+export const has = n => s => ((s >> n) & 1) === 1;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+export const set = n => s => s | one(n);
+/** @type {(n: NibbleSet) => NibbleSet} */
+export const complement = s => universe ^ s;
+/** @type {(n: Nibble) => (s: NibbleSet) => NibbleSet} */
+export const unset = n => s => s & complement(one(n));
+/** @type {(r: readonly[number, number]) => NibbleSet} */
+const range = ([a, b]) => one(b - a + 1) - 1 << a;
+/** @type {(r: readonly[number, number]) => (s: NibbleSet) => NibbleSet} */
+export const setRange = r => s => s | range(r);

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

@@ -0,0 +1,90 @@
+import * as list from '../list/module.f.mjs';
+const { every, map, countdown } = list;
+import * as _ from './module.f.mjs';
+export default {
+    has: () => {
+        if (_.has(0)(_.empty)) {
+            throw _.empty;
+        }
+        if (_.has(1)(_.empty)) {
+            throw _.empty;
+        }
+        if (_.has(15)(_.empty)) {
+            throw _.empty;
+        }
+    },
+    set: [
+        () => {
+            const s = _.set(0)(_.empty);
+            if (s !== 1) {
+                throw s;
+            }
+            if (!_.has(0)(s)) {
+                throw s;
+            }
+            if (_.has(1)(s)) {
+                throw s;
+            }
+            if (_.has(15)(s)) {
+                throw s;
+            }
+        },
+        () => {
+            const s = _.set(15)(_.empty);
+            if (s !== 0x8000) {
+                throw s;
+            }
+            if (_.has(0)(s)) {
+                throw s;
+            }
+            if (_.has(1)(s)) {
+                throw s;
+            }
+            if (!_.has(15)(s)) {
+                throw s;
+            }
+        }
+    ],
+    unset: () => [
+        () => {
+            const a = _.set(0)(_.empty);
+            const result = _.unset(0)(a);
+            if (result !== 0) {
+                throw result;
+            }
+        },
+        () => {
+            const a = _.set(15)(_.empty);
+            const result = _.unset(15)(a);
+            if (result !== 0) {
+                throw result;
+            }
+        }
+    ],
+    setRange: () => {
+        const result = _.setRange([2, 5])(_.empty);
+        if (result !== 60) {
+            throw result;
+        }
+    },
+    universe: () => {
+        const x = every(map(v => _.has(v)(_.universe))(countdown(16)));
+        if (!x) {
+            throw x;
+        }
+    },
+    compliment: {
+        empty: () => {
+            const r = _.complement(_.empty);
+            if (r !== _.universe) {
+                throw r;
+            }
+        },
+        universe: () => {
+            const r = _.complement(_.universe);
+            if (r !== _.empty) {
+                throw r;
+            }
+        },
+    }
+};

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

@@ -0,0 +1,9 @@
+/**
+ * @template T
+ * @typedef {T|null} Nullable
+ */
+/** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
+export const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
+/** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
+export const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;
+export type Nullable<T> = T | null;

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

@@ -0,0 +1,9 @@
+// @ts-self-types="./module.f.d.mts"
+/**
+ * @template T
+ * @typedef {T|null} Nullable
+ */
+/** @type {<T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>} */
+export const map = f => value => value === null ? null : f(value);
+/** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>} */
+export const match = f => none => value => value === null ? none() : f(value);

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

@@ -0,0 +1,12 @@
+import * as _ from './module.f.mjs';
+export default () => {
+    const optionSq = _.map(v => v * v);
+    const sq3 = optionSq(3);
+    if (sq3 !== 9) {
+        throw sq3;
+    }
+    const sqNull = optionSq(null);
+    if (sqNull !== null) {
+        throw sqNull;
+    }
+};

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

@@ -0,0 +1,7 @@
+export const sum: (input: list.List<number>) => number;
+export const min: (input: list.List<number>) => number | null;
+export const max: (input: list.List<number>) => number | null;
+/** @type {(a: number) => (b: number) => compare.Sign} */
+export const cmp: (a: number) => (b: number) => compare.Sign;
+import * as list from '../list/module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';

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

@@ -0,0 +1,12 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../list/module.f.mjs';
+const { reduce } = list;
+import * as operator from '../function/operator/module.f.mjs';
+const { addition, min: minOp, max: maxOp } = operator;
+import * as compare from '../function/compare/module.f.mjs';
+const { unsafeCmp } = compare;
+export const sum = reduce(addition)(0);
+export const min = reduce(minOp)(null);
+export const max = reduce(maxOp)(null);
+/** @type {(a: number) => (b: number) => compare.Sign} */
+export const cmp = unsafeCmp;

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

@@ -0,0 +1,126 @@
+import * as _ from './module.f.mjs';
+const { sum, min, max, cmp } = _;
+export default {
+    sum: () => {
+        const result = sum([2, 3, 4, 5]);
+        if (result !== 14) {
+            throw result;
+        }
+    },
+    min: {
+        empty: () => {
+            const result = min([]);
+            if (result !== null) {
+                throw result;
+            }
+        },
+        multi: () => {
+            const result = min([1, 2, 12, -4, 8]);
+            if (result !== -4) {
+                throw result;
+            }
+        }
+    },
+    max: () => {
+        const result = max([1, 2, 12, -4, 8]);
+        if (result !== 12) {
+            throw result;
+        }
+    },
+    cmp: () => {
+        const result = cmp(4)(5);
+        if (result !== -1) {
+            throw result;
+        }
+    },
+    standard: () => {
+        /** @type {(a: bigint) => (a: bigint) => void} */
+        const check = a => b => {
+            if (BigInt(Number(a)) != b) {
+                throw [a, b];
+            }
+        };
+        /** @type {(v: bigint) => void} */
+        const eq = v => check(v)(v);
+        // 53, 0x35 bits.
+        //        3                   2                   1                   0
+        //   4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210
+        eq(4503599627370496n);
+        eq(4503599627370497n);
+        eq(4503599627370498n);
+        eq(4503599627370499n);
+        eq(4503599627370500n);
+        //
+        eq(8205552883602248n);
+        eq(6023495077481713n);
+        eq(7655550916643882n);
+        eq(7408615831253283n);
+        eq(5372046171422892n);
+        //
+        eq(9007199254740991n);
+        eq(9007199254740990n);
+        eq(9007199254740989n);
+        eq(9007199254740988n);
+        eq(9007199254740987n);
+        eq(9007199254740986n);
+        eq(9007199254740985n);
+        eq(9007199254740984n);
+        // 54, 0x35+1 bits.
+        //           3                   2                   1                   0
+        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1
+        check(9007199254740992n)(9007199254740992n);
+        check(16585805050637558n)(16585805050637558n);
+        check(18014398509481982n)(18014398509481982n);
+        // round down
+        check(9007199254740993n)(9007199254740992n);
+        check(9007199254740997n)(9007199254740996n);
+        check(11727370849309157n)(11727370849309156n);
+        check(18014398509481981n)(18014398509481980n);
+        // round up
+        check(9007199254740995n)(9007199254740996n);
+        check(15679542343753527n)(15679542343753528n);
+        check(18014398509481983n)(18014398509481984n);
+        // 55, 0x35+2 bits.
+        //           3                   2                   1                   0
+        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_12
+        // 0_xx: down, down, up
+        // 0_00
+        check(18014398509481984n)(18014398509481984n);
+        check(31009640954244032n)(31009640954244032n);
+        check(36028797018963960n)(36028797018963960n);
+        // 0_01 round down
+        check(18014398509481985n)(18014398509481984n);
+        check(35865859090492321n)(35865859090492320n);
+        check(36028797018963961n)(36028797018963960n);
+        // 0_10 round down
+        check(18014398509481986n)(18014398509481984n);
+        check(20537830900813786n)(20537830900813784n);
+        check(36028797018963962n)(36028797018963960n);
+        // 0_11 round up
+        check(18014398509481987n)(18014398509481988n);
+        check(20762549594556867n)(20762549594556868n);
+        check(36028797018963963n)(36028797018963964n);
+        // 1_xx: down, up, up
+        // 1_00
+        check(18014398509481988n)(18014398509481988n);
+        check(27158415062912468n)(27158415062912468n);
+        check(36028797018963963n)(36028797018963964n);
+        // 1_01 round down
+        check(18014398509481989n)(18014398509481988n);
+        check(23136524663958789n)(23136524663958788n);
+        check(36028797018963965n)(36028797018963964n);
+        // 1_10 round up
+        check(18014398509481990n)(18014398509481992n);
+        check(35732739218314830n)(35732739218314832n);
+        check(36028797018963966n)(36028797018963968n);
+        // 1_11 round up
+        check(18014398509481991n)(18014398509481992n);
+        check(35015291789494295n)(35015291789494296n);
+        check(36028797018963967n)(36028797018963968n);
+        // 57, 0x35+4 bits.
+        //           3                   2                   1                   0
+        //      4_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_FEDC_BA98_7654_3210_1234
+        check(104002482718319358n)(104002482718319360n);
+        check(142693895881191444n)(142693895881191440n);
+    }
+};

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

@@ -0,0 +1,22 @@
+/**
+ * @template T
+ * @typedef {{
+ *  readonly [k in string]: T
+ * }} Map
+ */
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+/** @type {(name: string) => <T>(object: Map<T>) => T|null} */
+export const at: (name: string) => <T>(object: Map<T>) => T | null;
+/** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
+export const sort: <T>(e: list.List<Entry<T>>) => list.List<Entry<T>>;
+/** @type {<T>(e: list.List<Entry<T>>) => Map<T>} */
+export const fromEntries: <T>(e: list.List<Entry<T>>) => Map<T>;
+/** @type {<T>(m: btMap.Map<T>) => Map<T>} */
+export const fromMap: <T>(m: btMap.Map<T>) => Map<T>;
+export type Map<T> = { readonly [k in string]: T; };
+export type Entry<T> = readonly [string, T];
+import * as list from '../list/module.f.mjs';
+import * as btMap from '../map/module.f.mjs';

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

@@ -0,0 +1,27 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../list/module.f.mjs';
+const { iterable } = list;
+import * as btMap from '../map/module.f.mjs';
+const { entries: mapEntries, fromEntries: mapFromEntries } = btMap;
+const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
+/**
+ * @template T
+ * @typedef {{
+ *  readonly [k in string]: T
+ * }} Map
+ */
+/**
+ * @template T
+ * @typedef {readonly[string, T]} Entry
+ */
+/** @type {(name: string) => <T>(object: Map<T>) => T|null} */
+export const at = name => object => {
+    const r = getOwnPropertyDescriptor(object, name);
+    return r === void 0 ? null : r.value;
+};
+/** @type {<T>(e: list.List<Entry<T>>) => list.List<Entry<T>>} */
+export const sort = e => mapEntries(mapFromEntries(e));
+/** @type {<T>(e: list.List<Entry<T>>) => Map<T>} */
+export const fromEntries = e => objectFromEntries(iterable(e));
+/** @type {<T>(m: btMap.Map<T>) => Map<T>} */
+export const fromMap = m => fromEntries(mapEntries(m));

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

@@ -0,0 +1,17 @@
+import * as _ from './module.f.mjs';
+export default {
+    ctor: () => {
+        const a = {};
+        const value = _.at('constructor')(a);
+        if (value !== null) {
+            throw value;
+        }
+    },
+    property: () => {
+        const a = { constructor: 42 };
+        const value = _.at('constructor')(a);
+        if (value !== 42) {
+            throw value;
+        }
+    }
+};

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

@@ -0,0 +1,6 @@
+/** @typedef {readonly[number,number]} Range */
+/** @type {(range: Range) => (i: number) => boolean} */
+export const contains: (range: Range) => (i: number) => boolean;
+/** @type {(i: number) => Range} */
+export const one: (i: number) => Range;
+export type Range = readonly [number, number];

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

@@ -0,0 +1,6 @@
+// @ts-self-types="./module.f.d.mts"
+/** @typedef {readonly[number,number]} Range */
+/** @type {(range: Range) => (i: number) => boolean} */
+export const contains = ([b, e]) => i => b <= i && i <= e;
+/** @type {(i: number) => Range} */
+export const one = a => [a, a];

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

@@ -0,0 +1,18 @@
+import * as _ from './module.f.mjs';
+export default () => {
+    if (!_.contains([0, 5])(1)) {
+        throw 1;
+    }
+    if (!_.contains([0, 5])(0)) {
+        throw 0;
+    }
+    if (!_.contains([0, 5])(5)) {
+        throw 5;
+    }
+    if (_.contains([0, 5])(-1)) {
+        throw -1;
+    }
+    if (_.contains([0, 5])(6)) {
+        throw 6;
+    }
+};

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

@@ -1,11 +1,11 @@
-declare namespace _default {
-    export { merge };
-    export { get };
-    export { fromRange };
-}
-export default _default;
+/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
+export const merge: <T>(op: Operators<T>) => RangeMerge<T>;
+/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
+export const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
+/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
+export const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
 export type Entry<T> = [T, number];
-export type RangeMap<T> = SortedList.SortedList<Entry<T>>;
+export type RangeMap<T> = sortedList.SortedList<Entry<T>>;
 export type RangeMapArray<T> = readonly Entry<T>[];
 export type Operators<T> = {
     readonly union: O.Reduce<T>;
@@ -13,13 +13,7 @@ export type Operators<T> = {
 };
 export type RangeState<T> = Option.Nullable<Entry<T>>;
 export type RangeMerge<T> = O.Reduce<RangeMap<T>>;
-/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
-declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
-/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
-declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
-/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
-declare const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;
-import * as SortedList from '../sorted_list/module.f.mjs';
+import * as Range from '../range/module.f.mjs';
+import * as sortedList from '../sorted_list/module.f.mjs';
 import * as O from '../function/operator/module.f.mjs';
 import * as Option from '../nullable/module.f.mjs';
-import * as Range from '../range/module.f.mjs';