functionalscript 0.3.4 → 0.3.6

package/types/list/test.f.js

@@ -0,0 +1,395 @@
+import * as _ from "./module.f.js";
+import * as json from "../../json/module.f.js";
+import * as o from "../object/module.f.js";
+const { sort } = o;
+import * as operator from "../function/operator/module.f.js";
+const { addition, strictEqual, reduceToScan } = operator;
+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: () => {
+        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: () => {
+        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: () => {
+        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: () => {
+        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: () => {
+        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/types/map/module.f.d.ts

@@ -0,0 +1,14 @@
+import * as BtreeTypes from '../btree/types/module.f.ts';
+import * as Compare from '../function/compare/module.f.ts';
+import * as list from '../list/module.f.ts';
+import * as Operator from '../function/operator/module.f.ts';
+export type Sign = Compare.Sign;
+export type Entry<T> = readonly [string, T];
+export type Map<T> = BtreeTypes.Tree<Entry<T>>;
+export declare const at: (name: string) => <T>(map: Map<T>) => T | null;
+export declare const setReduce: <T>(reduce: Operator.Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
+export declare const setReplace: (name: string) => <T>(value: T) => (map: Map<T>) => Map<T>;
+export declare const entries: <T>(map: Map<T>) => list.List<Entry<T>>;
+export declare const fromEntries: <T>(entries: list.List<Entry<T>>) => Map<T>;
+export declare const remove: (name: string) => <T>(map: Map<T>) => Map<T>;
+export declare const empty: null;

package/types/map/module.f.js

@@ -0,0 +1,31 @@
+import * as BtreeTypes from "../btree/types/module.f.js";
+import * as btf from "../btree/find/module.f.js";
+const { value, find } = btf;
+import * as bts from "../btree/set/module.f.js";
+const { set } = bts;
+import * as btr from "../btree/remove/module.f.js";
+const { remove: btreeRemove } = btr;
+import * as bt from "../btree/module.f.js";
+const { values } = bt;
+import * as Compare from "../function/compare/module.f.js";
+import * as s from "../string/module.f.js";
+const { cmp } = s;
+import * as list from "../list/module.f.js";
+const { fold } = list;
+import * as Operator from "../function/operator/module.f.js";
+const keyCmp = a => ([b]) => cmp(a)(b);
+export const at = (name) => (map) => {
+    if (map === null) {
+        return null;
+    }
+    const result = value(find(keyCmp(name))(map).first);
+    return result === null ? null : result[1];
+};
+const setReduceEntry = reduce => entry => set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])]);
+export const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value]);
+const replace = () => b => b;
+export const setReplace = name => value => setReduceEntry(replace)([name, value]);
+export const entries = values;
+export const fromEntries = fold(setReduceEntry(replace))(null);
+export const remove = name => btreeRemove(keyCmp(name));
+export const empty = null;

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

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

package/types/map/test.f.js

@@ -0,0 +1,114 @@
+import * as _ from "./module.f.js";
+const { at, setReplace, setReduce, empty, entries, remove } = _;
+import * as seq from "../list/module.f.js";
+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: () => {
+        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/types/nibble_set/module.f.d.ts

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

package/types/nibble_set/module.f.js

@@ -0,0 +1,9 @@
+export const empty = 0;
+export const universe = 0xFFFF;
+const one = n => 1 << n;
+export const has = n => s => ((s >> n) & 1) === 1;
+export const set = n => s => s | one(n);
+export const complement = s => universe ^ s;
+export const unset = n => s => s & complement(one(n));
+const range = ([a, b]) => one(b - a + 1) - 1 << a;
+export const setRange = r => s => s | range(r);

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

@@ -0,0 +1,12 @@
+declare const _default: {
+    has: () => void;
+    set: (() => void)[];
+    unset: () => (() => void)[];
+    setRange: () => void;
+    universe: () => void;
+    compliment: {
+        empty: () => void;
+        universe: () => void;
+    };
+};
+export default _default;

package/types/nibble_set/test.f.js

@@ -0,0 +1,90 @@
+import * as list from "../list/module.f.js";
+const { every, map, countdown } = list;
+import * as _ from "./module.f.js";
+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/types/nullable/module.f.d.ts

@@ -0,0 +1,3 @@
+export type Nullable<T> = T | null;
+export declare const map: <T, R>(f: (value: T) => R) => (value: Nullable<T>) => Nullable<R>;
+export declare const match: <T, R>(f: (_: T) => R) => (none: () => R) => (_: Nullable<T>) => Nullable<R>;

package/types/nullable/module.f.js

@@ -0,0 +1,2 @@
+export const map = f => value => value === null ? null : f(value);
+export const match = f => none => value => value === null ? none() : f(value);

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

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