functionalscript 0.2.0 → 0.2.2

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.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.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/out/types/range_map/module.f.mjs

@@ -0,0 +1,84 @@
+// @ts-self-types="./module.f.d.mts"
+import * as sortedList from '../sorted_list/module.f.mjs';
+const { genericMerge } = sortedList;
+import * as list from '../list/module.f.mjs';
+const { next } = list;
+import * as Option from '../nullable/module.f.mjs';
+import * as number from '../number/module.f.mjs';
+const { cmp } = number;
+import * as O from '../function/operator/module.f.mjs';
+import * as Range from '../range/module.f.mjs';
+/**
+ * @template T
+ * @typedef {[T, number]} Entry
+ */
+/**
+ * @template T
+ * @typedef {sortedList.SortedList<Entry<T>>} RangeMap
+ */
+/**
+ * @template T
+ * @typedef {readonly Entry<T>[]} RangeMapArray
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly union: O.Reduce<T>
+ *  readonly equal: O.Equal<T>
+ * }} Operators
+ */
+/**
+ * @template T
+ * @typedef {Option.Nullable<Entry<T>>} RangeState
+ */
+/**
+ * @template T
+ * @typedef {O.Reduce<RangeMap<T>>} RangeMerge
+ */
+/** @type {<T>(union: O.Reduce<T>) => (equal: O.Equal<T>) => sortedList.ReduceOp<Entry<T>, RangeState<T>>} */
+const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax]) => {
+    const sign = cmp(aMax)(bMax);
+    const min = sign === 1 ? bMax : aMax;
+    const u = union(aItem)(bItem);
+    const newState = state !== null && equal(state[0])(u) ? null : state;
+    return [newState, sign, [u, min]];
+};
+/** @type {<T>(equal: O.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
+const tailReduce = equal => state => tail => {
+    if (state === null) {
+        return tail;
+    }
+    const tailResult = next(tail);
+    if (tailResult === null) {
+        return [state];
+    }
+    if (equal(state[0])(tailResult.first[0])) {
+        return tailResult;
+    }
+    return { first: state, tail: tailResult };
+};
+/** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
+export const merge = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null);
+/** @type {<T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T} */
+export const get = def => value => rm => {
+    const len = rm.length;
+    let b = 0;
+    let e = len - 1;
+    while (true) {
+        if (b >= len) {
+            return def;
+        }
+        if (e - b < 0) {
+            return rm[b][0];
+        }
+        const mid = b + (e - b >> 1);
+        if (value <= rm[mid][1]) {
+            e = mid - 1;
+        }
+        else {
+            b = mid + 1;
+        }
+    }
+};
+/** @type {<T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>} */
+export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]];

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

@@ -0,0 +1,201 @@
+import * as _ from './module.f.mjs';
+import * as compare from '../function/compare/module.f.mjs';
+const { unsafeCmp } = compare;
+import * as json from '../../json/module.f.mjs';
+import * as object from '../object/module.f.mjs';
+const { sort } = object;
+import * as sortedSet from '../sorted_set/module.f.mjs';
+import * as list from '../list/module.f.mjs';
+import * as operator from '../function/operator/module.f.mjs';
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = json.stringify(sort);
+/** @type {_.Operators<sortedSet.SortedSet<string>>} */
+const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) };
+export default {
+    merge: [
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]];
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = null;
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a"],1],[["b"],2]]') {
+                throw result;
+            }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = null;
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]];
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a"],1],[["b"],2]]') {
+                throw result;
+            }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]];
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]];
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a"],1],[["b"],2]]') {
+                throw result;
+            }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['c'], 3]];
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 2], [['d'], 4]];
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') {
+                throw result;
+            }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['d'], 4]];
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 2], [['c'], 3]];
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') {
+                throw result;
+            }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]];
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 1], [['a'], 2]];
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a","b"],2]]') {
+                throw result;
+            }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 5]];
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') {
+                throw result;
+            }
+        }
+    ],
+    get: () => {
+        /** @type {sortedSet.SortedSet<string>} */
+        const sortedSetEmpty = [];
+        const get = _.get(sortedSetEmpty);
+        return [
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(5)(rm));
+                if (result !== '["a"]') {
+                    throw result;
+                }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(10)(rm));
+                if (result !== '["a"]') {
+                    throw result;
+                }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(15)(rm));
+                if (result !== '["b"]') {
+                    throw result;
+                }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(20)(rm));
+                if (result !== '["b"]') {
+                    throw result;
+                }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(25)(rm));
+                if (result !== '["c"]') {
+                    throw result;
+                }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(30)(rm));
+                if (result !== '["c"]') {
+                    throw result;
+                }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(35)(rm));
+                if (result !== '[]') {
+                    throw result;
+                }
+            },
+            () => {
+                /** @type {_.RangeMapArray<sortedSet.SortedSet<string>>} */
+                const rm = [];
+                const result = stringify(get(10)(rm));
+                if (result !== '[]') {
+                    throw result;
+                }
+            }
+        ];
+    },
+    fromRange: () => {
+        const def = -1;
+        const rm = _.fromRange(def)([1, 7])(42);
+        return [
+            () => {
+                const result = _.get(def)(0)(rm);
+                if (result !== -1) {
+                    throw result;
+                }
+            },
+            () => {
+                const result = _.get(def)(1)(rm);
+                if (result !== 42) {
+                    throw result;
+                }
+            },
+            () => {
+                const result = _.get(def)(3)(rm);
+                if (result !== 42) {
+                    throw result;
+                }
+            },
+            () => {
+                const result = _.get(def)(7)(rm);
+                if (result !== 42) {
+                    throw result;
+                }
+            },
+            () => {
+                const result = _.get(def)(9)(rm);
+                if (result !== -1) {
+                    throw result;
+                }
+            },
+        ];
+    }
+};

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

@@ -0,0 +1,25 @@
+// @ts-self-types="./module.f.d.mts"
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+/** @type {<T>(value: T) => Ok<T>} */
+export const ok = value => ['ok', value];
+/** @type {<E>(e: E) => Error<E>} */
+export const error = e => ['error', e];
+/** @type {<T, E>(r: Result<T, E>) => T} */
+export const unwrap = ([kind, v]) => {
+    if (kind === 'error') {
+        throw v;
+    }
+    return v;
+};

package/out/types/result/module.mjs

@@ -0,0 +1,16 @@
+import * as result from './module.f.mjs';
+const { ok, error } = result;
+/** @type {<T>(f: () => T) => result.Result<T, unknown>} */
+const tryCatch = f => {
+    // Side effect: `try catch` is not allowed in FunctionalScript.
+    try {
+        return ok(f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+export default {
+    /** @readonly */
+    tryCatch,
+};

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

@@ -0,0 +1,102 @@
+// @ts-self-types="./module.f.d.mts"
+import * as compare from '../function/compare/module.f.mjs';
+import * as list from '../list/module.f.mjs';
+import * as option from '../nullable/module.f.mjs';
+const { next } = list;
+import * as f from '../function/module.f.mjs';
+const { identity } = f;
+/**
+ * @template T
+ * @typedef {list.List<T>} SortedList
+ */
+/**
+ * @template T
+ * @typedef {readonly T[]} SortedArray
+ */
+/**
+ * @template T
+ * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
+ */
+/**
+ * @template T
+ * @template S
+ * @typedef {(state: S) => (a: T) => (b: T) => readonly[option.Nullable<T>, compare.Sign, S]} ReduceOp
+ */
+/**
+ * @template T
+ * @template S
+ * @typedef {(state: S) => (tail: list.List<T>) => list.List<T>} TailReduce
+ */
+/**
+ * @template T
+ * @template S
+  * @typedef {{
+ *  readonly reduceOp: ReduceOp<T,S>
+ *  readonly tailReduce: TailReduce<T,S>
+  * }} MergeReduce
+ */
+/** @type {<T,S>(reduce: MergeReduce<T,S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
+export const genericMerge = ({ reduceOp, tailReduce }) => {
+    /** @typedef {typeof reduceOp extends ReduceOp<infer T, infer S> ? [T, S] : never} TS */
+    /** @typedef {TS[0]} T */
+    /** @typedef {TS[1]} S */
+    /** @type {(state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>} */
+    const f = state => a => b => () => {
+        const aResult = next(a);
+        if (aResult === null) {
+            return tailReduce(state)(b);
+        }
+        const bResult = next(b);
+        if (bResult === null) {
+            return tailReduce(state)(aResult);
+        }
+        const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first);
+        const aNext = sign === 1 ? a : aResult.tail;
+        const bNext = sign === -1 ? b : bResult.tail;
+        const tail = f(stateNext)(aNext)(bNext);
+        return first === null ? tail : { first, tail };
+    };
+    return f;
+};
+/**
+ * @template T
+ * @typedef {ReduceOp<T, null>} CmpReduceOp
+ */
+/** @type {<T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>} */
+export const merge = cmp => {
+    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
+    /** @type {TailReduce<T, null>} */
+    const tailReduce = mergeTail;
+    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null);
+};
+/** @type {<T>(cmp: Cmp<T>) => CmpReduceOp<T>} */
+const cmpReduce = cmp => () => a => b => {
+    const sign = cmp(a)(b);
+    return [sign === 1 ? b : a, sign, null];
+};
+/** @type {() => <T>(tail: list.List<T>) => list.List<T>} */
+const mergeTail = () => identity;
+/** @type {<T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) =>  T|null} */
+export const find = cmp => value => array => {
+    let b = 0;
+    let e = array.length - 1;
+    while (true) {
+        if (e - b < 0)
+            return null;
+        const mid = b + (e - b >> 1);
+        const sign = cmp(value)(array[mid]);
+        switch (sign) {
+            case -1: {
+                e = mid - 1;
+                break;
+            }
+            case 0: {
+                return value;
+            }
+            case 1: {
+                b = mid + 1;
+                break;
+            }
+        }
+    }
+};