functionalscript 0.2.5 → 0.3.0

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

@@ -1,269 +0,0 @@
-// @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.d.mts

@@ -1,38 +0,0 @@
-declare namespace _default {
-    export { stringifyTest };
-    export { cycle };
-    export { countdown };
-    export { flat };
-    export { concat };
-    export { flatMap };
-    export { take };
-    export { find };
-    export { takeWhile };
-    export { dropWhile };
-    export { drop };
-    export { additionTests };
-    export { entries };
-    export { reverse };
-    export { zip };
-    export { logic };
-    export let strictEqual: (() => void)[];
-    export let isEmpty: (() => void)[];
-    export function length(): void;
-}
-export default _default;
-declare function stringifyTest(): void;
-declare function cycle(): void;
-declare function countdown(): void;
-declare function flat(): void;
-declare function concat(): void;
-declare function flatMap(): void;
-declare const take: (() => void)[];
-declare const find: (() => void)[];
-declare const takeWhile: (() => void)[];
-declare function dropWhile(): void;
-declare const drop: (() => void)[];
-declare const additionTests: (() => void)[];
-declare const entries: (() => void)[];
-declare const reverse: (() => void)[];
-declare const zip: (() => void)[];
-declare function logic(): (() => void)[];

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

@@ -1,401 +0,0 @@
-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
-};