functionalscript 0.1.609 → 0.2.1

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

@@ -0,0 +1,269 @@
+// @ts-self-types="./module.f.d.mts"
+import * as function_ from '../function/module.f.mjs';
+const { identity, fn, compose } = function_;
+import * as operator from '../function/operator/module.f.mjs';
+const { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan } = operator;
+/**
+ * @template T
+ * @typedef {NotLazy<T> | Thunk<T>} List
+ */
+/**
+ * @template T
+ * @typedef {|
+ *  Result<T> |
+ *  Concat<T> |
+ *  readonly T[]
+ * } NotLazy
+ */
+/** @typedef {null} Empty */
+/**
+ * @template T
+ * @typedef {Empty | NonEmpty<T>} Result
+ */
+/**
+ * @template T
+ * @typedef {() => List<T>} Thunk
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: T
+ *  readonly tail: List<T>
+ * }} NonEmpty
+ */
+/**
+ * @template T
+ * @typedef {{
+ *  readonly head: List<T>
+ *  readonly tail: List<T>
+ * }} Concat
+ */
+/** @type {<T>(array: readonly T[]) => Result<T>} */
+const fromArray = array => {
+    /** @typedef {typeof array extends readonly (infer T)[] ? T : never} T */
+    /** @type {(i: number) => Result<T>} */
+    const at = i => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
+    return at(0);
+};
+/** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
+export const concat = head => tail => tail === null ? head : ({ head, tail });
+/** @type {<T>(list: List<T>) => NotLazy<T> } */
+const trampoline = list => {
+    while (typeof list === 'function') {
+        list = list();
+    }
+    return list;
+};
+/** @type {<T>(list: List<T>) => Result<T>} */
+export const next = head => {
+    /** @type {typeof head} */
+    let tail = null;
+    while (true) {
+        head = trampoline(head);
+        if (head instanceof Array) {
+            head = fromArray(head);
+        }
+        else if (head !== null && 'head' in head) {
+            [head, tail] = [head.head, concat(head.tail)(tail)];
+            continue;
+        }
+        if (head !== null) {
+            return { first: head.first, tail: concat(head.tail)(tail) };
+        }
+        if (tail === null) {
+            return null;
+        }
+        [head, tail] = [tail, null];
+    }
+};
+/** @type {<T>(list: List<T>) => Iterable<T>} */
+export const iterable = list => ({
+    *[Symbol.iterator]() {
+        let i = list;
+        while (true) {
+            const r = next(i);
+            if (r === null) {
+                return;
+            }
+            yield r.first;
+            i = r.tail;
+        }
+    }
+});
+const { from } = Array;
+/** @type {<T>(list: List<T>) => readonly T[]} */
+export const toArray = list => {
+    const u = trampoline(list);
+    return u instanceof Array ? u : from(iterable(u));
+};
+/** @type {<I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => Thunk<O>} */
+const apply = f => input => () => {
+    const n = next(input);
+    if (n === null) {
+        return null;
+    }
+    return f(n);
+};
+/** @type {<T>(n: NonEmpty<List<T>>) => List<T>} */
+const flatStep = ({ first, tail }) => concat(first)(flat(tail));
+/** @type {<T>(list: List<List<T>>) => Thunk<T>} */
+export const flat = apply(flatStep);
+/** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
+const mapStep = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) });
+/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
+export const map = f => apply(mapStep(f));
+/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
+export const flatMap = f => compose(map(f))(flat);
+/** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
+const filterStep = f => ({ first, tail }) => {
+    const newTail = filter(f)(tail);
+    return f(first) ? { first, tail: newTail } : newTail;
+};
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+export const filter = f => apply(filterStep(f));
+/** @type {<I, O>(f: (value: I) => O|null) => (n: NonEmpty<I>) => List<O>} */
+const filterMapStep = f => n => {
+    const [first, tail] = [f(n.first), filterMap(f)(n.tail)];
+    return first === null ? tail : { first, tail };
+};
+/** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
+export const filterMap = f => apply(filterMapStep(f));
+/** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
+const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } : null;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+export const takeWhile = f => apply(takeWhileStep(f));
+/** @type {(n: number) => <T>(result: NonEmpty<T>) => List<T>} */
+const takeStep = n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null;
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
+export const take = n => apply(takeStep(n));
+/** @type {<T>(f: (value: T) => boolean) => (ne: NonEmpty<T>) => List<T>} */
+const dropWhileStep = f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne;
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
+export const dropWhile = f => apply(dropWhileStep(f));
+/** @type {(n: number) => <T>(ne: NonEmpty<T>) => List<T>} */
+const dropStep = n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne;
+/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
+export const drop = n => apply(dropStep(n));
+/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
+export const first = def => input => {
+    const ne = next(input);
+    return ne === null ? def : ne.first;
+};
+/** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
+export const last = first => tail => {
+    /** @typedef {typeof tail extends List<infer T> ? T : never} T */
+    /** @type {NonEmpty<typeof first|T>} */
+    let i = { first, tail };
+    while (true) {
+        const result = next(i.tail);
+        if (result === null) {
+            return i.first;
+        }
+        i = result;
+    }
+};
+/** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
+export const find = def => f => compose(filter(f))(first(def));
+/** @type {(input: List<boolean>) => boolean} */
+export const some = find(false)(identity);
+/** @type {<T>(input: List<T>) => boolean} */
+export const isEmpty = fn(map(() => true))
+    .then(some)
+    .then(logicalNot)
+    .result;
+export const every = fn(map(logicalNot))
+    .then(some)
+    .then(logicalNot)
+    .result;
+/** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
+export const includes = value => compose(map(strictEqual(value)))(some);
+/** @type {(count: number) => Thunk<number>} */
+export const countdown = count => () => {
+    if (count <= 0) {
+        return null;
+    }
+    const first = count - 1;
+    return { first, tail: countdown(first) };
+};
+/** @type {<T>(v: T) => (c: number) => Thunk<T>} */
+export const repeat = v => compose(countdown)(map(() => v));
+/** @type {<T>(list: List<T>) => List<T>} */
+export const cycle = list => () => {
+    const i = next(list);
+    return i === null ? null : { first: i.first, tail: concat(i.tail)(cycle(list)) };
+};
+/** @type {<I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>} */
+const scanStep = op => ne => {
+    const [first, newOp] = op(ne.first);
+    return { first, tail: scan(newOp)(ne.tail) };
+};
+/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
+export const scan = op => apply(scanStep(op));
+/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
+export const stateScan = op => compose(stateScanToScan(op))(scan);
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
+export const foldScan = op => compose(foldToScan(op))(scan);
+/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
+export const fold = op => init => compose(foldScan(op)(init))(last(init));
+/** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+export const reduce = op => def => compose(scan(reduceToScan(op)))(last(def));
+/** @type {<T>(list: List<T>) => Thunk<number>} */
+const lengthList = list => () => {
+    const notLazy = trampoline(list);
+    if (notLazy === null) {
+        return null;
+    }
+    if (notLazy instanceof Array) {
+        return [notLazy.length];
+    }
+    const tail = lengthList(notLazy.tail);
+    if ("first" in notLazy) {
+        return { first: 1, tail };
+    }
+    return { head: lengthList(notLazy.head), tail };
+};
+const sum = reduce(addition)(0);
+/** @type {<T>(input: List<T>) => number} */
+export const length = compose(lengthList)(sum);
+/**
+ * @template T
+ * @typedef {readonly[number, T]} Entry
+ */
+/** @type {(index: number) => <T>(value: T) => readonly[Entry<T>, number]} */
+const entryOperator = index => value => [[index, value], index + 1];
+/** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
+export const entries = input => {
+    /** @typedef {typeof input extends List<infer T> ? T : never} T */
+    /** @type {operator.StateScan<T, Number, Entry<T>>} */
+    const o = entryOperator;
+    return stateScan(o)(0)(input);
+};
+/** @type {<T>(value: T) => (prior: List<T>) => List<T>} */
+const reverseOperator = first => tail => ({ first, tail });
+/** @type {<T>(input: List<T>) => List<T>} */
+export const reverse = fold(reverseOperator)(null);
+/** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
+export const zip = a => b => () => {
+    const aResult = next(a);
+    if (aResult === null) {
+        return null;
+    }
+    const bResult = next(b);
+    if (bResult === null) {
+        return null;
+    }
+    return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) };
+};
+/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
+export const equal = e => {
+    /** @typedef {typeof e extends operator.Equal<infer T> ? T : never} T */
+    /** @type {(a: List<T>) => (b: List<T>) => List<boolean>} */
+    const f = a => b => () => {
+        const [aResult, bResult] = [next(a), next(b)];
+        return aResult === null || bResult === null
+            ? { first: aResult === bResult, tail: null }
+            : { first: e(aResult.first)(bResult.first), tail: f(aResult.tail)(bResult.tail) };
+    };
+    return a => b => every(f(a)(b));
+};
+export const empty = null;

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.d.mts

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