functionalscript 0.3.3 → 0.3.5

package/types/nullable/test.f.js

@@ -0,0 +1,12 @@
+import * as _ from "./module.f.js";
+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/types/number/module.f.d.ts

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

package/types/number/module.f.js

@@ -0,0 +1,8 @@
+import { reduce } from "../list/module.f.js";
+import { addition, min as minOp, max as maxOp } from "../function/operator/module.f.js";
+import * as compare from "../function/compare/module.f.js";
+const { unsafeCmp } = compare;
+export const sum = reduce(addition)(0);
+export const min = reduce(minOp)(null);
+export const max = reduce(maxOp)(null);
+export const cmp = unsafeCmp;

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

@@ -0,0 +1,11 @@
+declare const _default: {
+    sum: () => void;
+    min: {
+        empty: () => void;
+        multi: () => void;
+    };
+    max: () => void;
+    cmp: () => void;
+    standard: () => void;
+};
+export default _default;

package/types/number/test.f.js

@@ -0,0 +1,124 @@
+import * as _ from "./module.f.js";
+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: () => {
+        const check = a => b => {
+            if (BigInt(Number(a)) != b) {
+                throw [a, b];
+            }
+        };
+        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/types/object/module.f.d.ts

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

package/types/object/module.f.js

@@ -0,0 +1,12 @@
+import * as list from "../list/module.f.js";
+const { iterable } = list;
+import * as btMap from "../map/module.f.js";
+const { entries: mapEntries, fromEntries: mapFromEntries } = btMap;
+const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
+export const at = name => object => {
+    const r = getOwnPropertyDescriptor(object, name);
+    return r === void 0 ? null : r.value;
+};
+export const sort = e => mapEntries(mapFromEntries(e));
+export const fromEntries = e => objectFromEntries(iterable(e));
+export const fromMap = m => fromEntries(mapEntries(m));

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    ctor: () => void;
+    property: () => void;
+};
+export default _default;

package/types/object/test.f.js

@@ -0,0 +1,17 @@
+import * as _ from "./module.f.js";
+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/types/range/module.f.d.ts

@@ -0,0 +1,3 @@
+export type Range = readonly [number, number];
+export declare const contains: (range: Range) => (i: number) => boolean;
+export declare const one: (i: number) => Range;

package/types/range/module.f.js

@@ -0,0 +1,2 @@
+export const contains = ([b, e]) => i => b <= i && i <= e;
+export const one = a => [a, a];

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

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/types/range/test.f.js

@@ -0,0 +1,18 @@
+import * as _ from "./module.f.js";
+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/range_map/module.f.d.ts

@@ -0,0 +1,14 @@
+import * as sortedList from '../sorted_list/module.f.ts';
+import * as O from '../function/operator/module.f.ts';
+import * as Range from '../range/module.f.ts';
+export type Entry<T> = [T, number];
+export type RangeMap<T> = sortedList.SortedList<Entry<T>>;
+export type RangeMapArray<T> = readonly Entry<T>[];
+export type Operators<T> = {
+    readonly union: O.Reduce<T>;
+    readonly equal: O.Equal<T>;
+};
+export type RangeMerge<T> = O.Reduce<RangeMap<T>>;
+export declare const merge: <T>(op: Operators<T>) => RangeMerge<T>;
+export declare const get: <T>(def: T) => (value: number) => (rm: RangeMapArray<T>) => T;
+export declare const fromRange: <T>(def: T) => (r: Range.Range) => (value: T) => RangeMapArray<T>;

package/types/range_map/module.f.js

@@ -0,0 +1,51 @@
+import * as sortedList from "../sorted_list/module.f.js";
+const { genericMerge } = sortedList;
+import * as list from "../list/module.f.js";
+const { next } = list;
+import * as Option from "../nullable/module.f.js";
+import * as number from "../number/module.f.js";
+const { cmp } = number;
+import * as O from "../function/operator/module.f.js";
+import * as Range from "../range/module.f.js";
+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]];
+};
+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 };
+};
+export const merge = ({ union, equal }) => genericMerge({ reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal) })(null);
+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;
+        }
+    }
+};
+export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]];

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

@@ -0,0 +1,6 @@
+declare const _default: {
+    merge: (() => void)[];
+    get: () => (() => void)[];
+    fromRange: () => (() => void)[];
+};
+export default _default;

package/types/range_map/test.f.js

@@ -0,0 +1,176 @@
+import * as _ from "./module.f.js";
+import * as compare from "../function/compare/module.f.js";
+const { unsafeCmp } = compare;
+import * as json from "../../json/module.f.js";
+import * as object from "../object/module.f.js";
+const { sort } = object;
+import * as sortedSet from "../sorted_set/module.f.js";
+import * as list from "../list/module.f.js";
+import * as operator from "../function/operator/module.f.js";
+const stringify = json.stringify(sort);
+const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) };
+export default {
+    merge: [
+        () => {
+            const a = [[['a'], 1], [['b'], 2]];
+            const b = null;
+            const merged = _.merge(op)(a)(b);
+            const result = stringify(list.toArray(merged));
+            if (result !== '[[["a"],1],[["b"],2]]') {
+                throw result;
+            }
+        },
+        () => {
+            const a = null;
+            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;
+            }
+        },
+        () => {
+            const a = [[['a'], 1], [['b'], 2]];
+            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;
+            }
+        },
+        () => {
+            const a = [[['a'], 1], [['c'], 3]];
+            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;
+            }
+        },
+        () => {
+            const a = [[['a'], 1], [['d'], 4]];
+            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;
+            }
+        },
+        () => {
+            const a = [[['a'], 1], [['b'], 2]];
+            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;
+            }
+        },
+        () => {
+            const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
+            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: () => {
+        const sortedSetEmpty = [];
+        const get = _.get(sortedSetEmpty);
+        return [
+            () => {
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(5)(rm));
+                if (result !== '["a"]') {
+                    throw result;
+                }
+            },
+            () => {
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(10)(rm));
+                if (result !== '["a"]') {
+                    throw result;
+                }
+            },
+            () => {
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(15)(rm));
+                if (result !== '["b"]') {
+                    throw result;
+                }
+            },
+            () => {
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(20)(rm));
+                if (result !== '["b"]') {
+                    throw result;
+                }
+            },
+            () => {
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(25)(rm));
+                if (result !== '["c"]') {
+                    throw result;
+                }
+            },
+            () => {
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(30)(rm));
+                if (result !== '["c"]') {
+                    throw result;
+                }
+            },
+            () => {
+                const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
+                const result = stringify(get(35)(rm));
+                if (result !== '[]') {
+                    throw result;
+                }
+            },
+            () => {
+                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/types/result/module.f.d.ts

@@ -0,0 +1,7 @@
+type Ok<T> = readonly ['ok', T];
+type Error<E> = readonly ['error', E];
+export type Result<T, E> = Ok<T> | Error<E>;
+export declare const ok: <T>(value: T) => Ok<T>;
+export declare const error: <E>(e: E) => Error<E>;
+export declare const unwrap: <T, E>(r: Result<T, E>) => T;
+export {};

package/types/result/module.f.js

@@ -0,0 +1,8 @@
+export const ok = value => ['ok', value];
+export const error = e => ['error', e];
+export const unwrap = ([kind, v]) => {
+    if (kind === 'error') {
+        throw v;
+    }
+    return v;
+};

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

@@ -0,0 +1,16 @@
+import * as compare from '../function/compare/module.f.ts';
+import * as list from '../list/module.f.ts';
+import * as option from '../nullable/module.f.ts';
+export type SortedList<T> = list.List<T>;
+type SortedArray<T> = readonly T[];
+type Cmp<T> = (a: T) => (b: T) => compare.Sign;
+export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [option.Nullable<T>, compare.Sign, S];
+export type TailReduce<T, S> = (state: S) => (tail: list.List<T>) => list.List<T>;
+type MergeReduce<T, S> = {
+    readonly reduceOp: ReduceOp<T, S>;
+    readonly tailReduce: TailReduce<T, S>;
+};
+export declare const genericMerge: <T, S>({ reduceOp, tailReduce }: MergeReduce<T, S>) => (state: S) => (a: list.List<T>) => (b: list.List<T>) => list.List<T>;
+export declare const merge: <T>(cmp: Cmp<T>) => (a: SortedList<T>) => (b: SortedList<T>) => SortedList<T>;
+export declare const find: <T>(cmp: Cmp<T>) => (value: T) => (array: SortedArray<T>) => T | null;
+export {};

package/types/sorted_list/module.f.js

@@ -0,0 +1,56 @@
+import * as compare from "../function/compare/module.f.js";
+import * as list from "../list/module.f.js";
+import * as option from "../nullable/module.f.js";
+const { next } = list;
+import * as f from "../function/module.f.js";
+const { identity } = f;
+export const genericMerge = ({ reduceOp, tailReduce }) => {
+    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;
+};
+export const merge = (cmp) => {
+    const tailReduce = mergeTail;
+    return genericMerge({ reduceOp: cmpReduce(cmp), tailReduce })(null);
+};
+const cmpReduce = cmp => () => a => b => {
+    const sign = cmp(a)(b);
+    return [sign === 1 ? b : a, sign, null];
+};
+const mergeTail = () => identity;
+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;
+            }
+        }
+    }
+};

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

@@ -0,0 +1,5 @@
+declare const _default: {
+    sortedMergre: (() => void)[];
+    find: (() => void)[];
+};
+export default _default;

package/types/sorted_list/test.f.js

@@ -0,0 +1,64 @@
+import * as _ from "./module.f.js";
+import * as compare from "../function/compare/module.f.js";
+const { unsafeCmp } = compare;
+import * as json from "../../json/module.f.js";
+import * as object from "../object/module.f.js";
+const { sort } = object;
+import * as list from "../list/module.f.js";
+const { toArray, countdown, length } = list;
+import * as Map from "../map/module.f.js";
+import * as f from "../function/module.f.js";
+const { flip } = f;
+const stringify = json.stringify(sort);
+const reverseCmp = flip(unsafeCmp);
+export default {
+    sortedMergre: [
+        () => {
+            const result = stringify(toArray(_.merge(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            if (result !== '[1,2,3,4,5]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = stringify(toArray(_.merge(unsafeCmp)([1, 2, 3])([])));
+            if (result !== '[1,2,3]') {
+                throw result;
+            }
+        },
+        () => {
+            const n = 10_000;
+            const list = countdown(n);
+            const result = _.merge(reverseCmp)(list)(list);
+            const len = length(result);
+            if (len != n) {
+                throw result;
+            }
+        }
+    ],
+    find: [
+        () => {
+            const result = _.find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result !== 0) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result !== null) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result !== null) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            if (result !== 80) {
+                throw result;
+            }
+        }
+    ]
+};

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

@@ -0,0 +1,7 @@
+import * as Compare from '../function/compare/module.f.ts';
+export type SortedSet<T> = readonly T[];
+type Cmp<T> = (a: T) => (b: T) => Compare.Sign;
+export declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
+export declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
+export declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;
+export {};