functionalscript 0.2.0 → 0.2.1

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

@@ -0,0 +1,401 @@
+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;
+import * as operator from '../function/operator/module.f.mjs';
+const { addition, strictEqual, reduceToScan } = operator;
+/** @type {(sequence: _.List<json.Unknown>) => string} */
+const stringify = sequence => json.stringify(sort)(_.toArray(sequence));
+const stringifyTest = () => {
+    const s = stringify([1, 2, 3]);
+    if (s !== '[1,2,3]') {
+        throw s;
+    }
+};
+const cycle = () => {
+    const x = stringify(_.toArray(_.take(10)(_.cycle([1, 2, 3]))));
+    if (x !== '[1,2,3,1,2,3,1,2,3,1]') {
+        throw x;
+    }
+};
+const countdown = () => {
+    const result = stringify(_.countdown(10));
+    if (result !== '[9,8,7,6,5,4,3,2,1,0]') {
+        throw result;
+    }
+};
+const flat = () => {
+    const result = stringify(_.flat([[1, 2, 3], [4, 5], [6], [], [7, 8, 9]]));
+    if (result !== '[1,2,3,4,5,6,7,8,9]') {
+        throw result;
+    }
+};
+const concat = () => {
+    const result = _.concat([1])([2]);
+    const x = _.next(result);
+    if (x === null) {
+        throw x;
+    }
+    if (x.first !== 1) {
+        throw x;
+    }
+};
+const flatMap = () => {
+    const result = stringify(_.flatMap(x => [x, x * 2, x * 3])([0, 1, 2, 3]));
+    if (result !== '[0,0,0,1,2,3,2,4,6,3,6,9]') {
+        throw result;
+    }
+};
+const take = [
+    () => {
+        const result = stringify(_.take(3)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        if (result !== '[1,2,3]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.take(20)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        if (result !== '[1,2,3,4,5,6,7,8,9]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.take(0)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        if (result !== '[]') {
+            throw result;
+        }
+    }
+];
+const find = [
+    () => {
+        const result = _.find(null)(x => x % 2 === 0)([1, 3, 5, 7]);
+        if (result !== null) {
+            throw result;
+        }
+    },
+    () => {
+        const result = _.find(null)(x => x % 2 === 0)([1, 2, 3, 4]);
+        if (result !== 2) {
+            throw result;
+        }
+    }
+];
+const takeWhile = [
+    () => {
+        const result = stringify(_.takeWhile(x => x < 10)([1, 2, 3, 4, 5, 10, 11]));
+        if (result !== '[1,2,3,4,5]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.takeWhile(x => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
+        if (result !== '[1,2,3,4,5]') {
+            throw result;
+        }
+    }
+];
+const dropWhile = () => {
+    const result = stringify(_.dropWhile(x => x < 10)([1, 2, 3, 4, 5, 10, 11]));
+    if (result !== '[10,11]') {
+        throw result;
+    }
+};
+const drop = [
+    () => {
+        const result = stringify(_.drop(3)([1, 2, 3, 4, 5, 10, 11]));
+        if (result !== '[4,5,10,11]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.drop(0)([1, 2, 3, 4, 5, 10, 11]));
+        if (result !== '[1,2,3,4,5,10,11]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.drop(10)([1, 2, 3, 4, 5, 10, 11]));
+        if (result !== '[]') {
+            throw result;
+        }
+    }
+];
+const additionTests = [
+    () => {
+        const op = reduceToScan(addition);
+        const result = stringify(_.scan(op)([2, 3, 4, 5]));
+        if (result !== '[2,5,9,14]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = _.reduce(addition)(null)([2, 3, 4, 5]);
+        if (result !== 14) {
+            throw result;
+        }
+    },
+    () => {
+        const result = _.reduce(addition)(null)([]);
+        if (result !== null) {
+            throw result;
+        }
+    }
+];
+const entries = [
+    () => {
+        const result = stringify(_.entries([]));
+        if (result !== '[]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.entries(['hello', 'world']));
+        if (result !== '[[0,"hello"],[1,"world"]]') {
+            throw result;
+        }
+    }
+];
+const reverse = [
+    () => {
+        const result = stringify(_.reverse([]));
+        if (result !== '[]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.reverse([1, 2, 3, 4, 5]));
+        if (result !== '[5,4,3,2,1]') {
+            throw result;
+        }
+    }
+];
+const zip = [
+    () => {
+        const result = stringify(_.zip([0, 1, 2])(['a', 'b', 'c', 'd']));
+        if (result !== '[[0,"a"],[1,"b"],[2,"c"]]') {
+            throw result;
+        }
+    },
+    () => {
+        const result = stringify(_.zip([0, 1, 2])(['a', 'b']));
+        if (result !== '[[0,"a"],[1,"b"]]') {
+            throw result;
+        }
+    }
+];
+const logic = () => {
+    const map5 = _.map(x => x > 5);
+    return [
+        () => {
+            const result = _.some(map5([0, 1, 7]));
+            if (!result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.some(map5([0, 1, 4]));
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.some(map5([]));
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.every(map5([0, 1, 7]));
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.every(map5([6, 11, 7]));
+            if (!result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.every(map5([]));
+            if (!result) {
+                throw result;
+            }
+        }
+    ];
+};
+// stress tests
+const stress = () => ({
+    toArray: () => {
+        // 200_000_000 is too much
+        const n = 100_000_000;
+        const result = _.toArray(_.countdown(n));
+        if (result.length !== n) {
+            throw result.length;
+        }
+        const len = _.length(_.filter(x => x > n)(result));
+        if (len !== 0) {
+            throw len;
+        }
+    },
+    first: () => {
+        // 100_000_000 is too much
+        const n = 50_000_000;
+        const result = _.toArray(_.countdown(n));
+        if (result.length !== n) {
+            throw result.length;
+        }
+        const first = _.first(null)(result);
+        if (first !== n - 1) {
+            throw first;
+        }
+    },
+    concatBack: () => {
+        /** @type {_.List<number>} */
+        let sequence = [];
+        // 20_000_000 is too much
+        // 10_000_000 is too much for Deno 1
+        for (let i = 0; i < 5_000_000; ++i) {
+            sequence = _.concat(sequence)([i]);
+        }
+        const r = _.toArray(sequence);
+    },
+    flatToArray: () => {
+        /** @type {_.List<number>} */
+        let sequence = [];
+        // 4_000_000 is too much
+        for (let i = 0; i < 2_000_000; ++i) {
+            sequence = _.flat([sequence, [i]]);
+        }
+        const r = _.toArray(sequence);
+    },
+    flatNext: () => {
+        /** @type {_.List<number>} */
+        let sequence = [];
+        // 4_000_000 is too much
+        for (let i = 0; i < 2_000_000; ++i) {
+            sequence = _.flat([sequence, [i]]);
+        }
+        const a = _.next(sequence);
+    },
+    concatFront: () => {
+        /** @type {_.List<number>} */
+        let sequence = [];
+        // 20_000_000 is too much
+        for (let i = 0; i < 10_000_000; ++i) {
+            sequence = _.concat([i])(sequence);
+        }
+        const a = _.next(sequence);
+    },
+    flatFront: () => {
+        /** @type {_.List<number>} */
+        let sequence = [];
+        // 10_000_000 is too much
+        for (let i = 0; i < 5_000_000; ++i) {
+            sequence = _.flat([[i], sequence]);
+        }
+        const a = _.next(sequence);
+    },
+    filterMap: () => {
+        // 100_000_000 is too much
+        const n = 50_000_000;
+        const result = _.toArray(_.countdown(n));
+        if (result.length !== n) {
+            throw result.length;
+        }
+        const len = _.length(_.filterMap(() => null)(result));
+        if (len !== 0) {
+            throw len;
+        }
+    },
+    dropWhile: () => {
+        // 50_000_000 is too much
+        const n = 20_000_000;
+        const result = _.toArray(_.countdown(n));
+        if (result.length !== n) {
+            throw result.length;
+        }
+        const len = _.length(_.dropWhile(() => true)(result));
+        if (len !== 0) {
+            throw len;
+        }
+    },
+    reverse: () => {
+        // 10_000_000 is too much
+        const n = 5_000_000;
+        const result = _.toArray(_.reverse(_.countdown(n)));
+        if (result.length !== n) {
+            throw result.length;
+        }
+    }
+});
+export default {
+    stringifyTest,
+    cycle,
+    countdown,
+    flat,
+    concat,
+    flatMap,
+    take,
+    find,
+    takeWhile,
+    dropWhile,
+    drop,
+    additionTests,
+    entries,
+    reverse,
+    zip,
+    logic,
+    strictEqual: [
+        () => {
+            const result = _.equal(strictEqual)([1])([2, 3]);
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.equal(strictEqual)([1, 3])([1]);
+            if (result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.equal(strictEqual)([15, 78])([15, 78]);
+            if (!result) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.equal(strictEqual)([])([]);
+            if (!result) {
+                throw result;
+            }
+        }
+    ],
+    isEmpty: [
+        () => {
+            const result = _.isEmpty(() => []);
+            if (result !== true) {
+                throw result;
+            }
+        },
+        () => {
+            const result = _.isEmpty(() => [2]);
+            if (result !== false) {
+                throw result;
+            }
+        }
+    ],
+    length: () => {
+        if (_.length([1, 2, 3]) !== 3) {
+            throw 3;
+        }
+        if (_.length(null) !== 0) {
+            throw 0;
+        }
+        if (_.length(_.flat([[1, 3], null, () => [3], _.concat([12])([4, 89])])) !== 6) {
+            throw 6;
+        }
+    },
+    // stress
+};

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.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.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;
+    }
+};