functionalscript 0.2.5 → 0.3.0

package/out/types/byte_set/module.f.d.mts

@@ -1,25 +0,0 @@
-/** @typedef {bigint} ByteSet */
-/** @typedef {number} Byte */
-/** @type {(n: Byte) => (s: ByteSet) => boolean} */
-export const has: (n: Byte) => (s: ByteSet) => boolean;
-export const empty: 0n;
-export const universe: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
-/** @type {(n: Byte) => ByteSet} */
-export const one: (n: Byte) => ByteSet;
-/** @type {(r: readonly[Byte, Byte]) => ByteSet} */
-export const range: (r: readonly [Byte, Byte]) => ByteSet;
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-export const union: (a: ByteSet) => (b: ByteSet) => ByteSet;
-/** @type {(n: ByteSet) => ByteSet} */
-export const complement: (n: ByteSet) => ByteSet;
-export const set: f.Func<number, (b: ByteSet) => ByteSet>;
-export const setRange: f.Func<readonly [number, number], (b: ByteSet) => ByteSet>;
-/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
-export const unset: (n: Byte) => (s: ByteSet) => ByteSet;
-/** @type {(n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
-export const toRangeMap: (n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>;
-export type ByteSet = bigint;
-export type Byte = number;
-import * as f from '../function/module.f.mjs';
-import * as RangeMap from '../range_map/module.f.mjs';
-import * as SortedSet from '../sorted_set/module.f.mjs';

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

@@ -1,42 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as f from '../function/module.f.mjs';
-const { compose } = f;
-import * as RangeMap from '../range_map/module.f.mjs';
-import * as SortedSet from '../sorted_set/module.f.mjs';
-import * as list from '../list/module.f.mjs';
-const { reverse, countdown, flat, map } = list;
-/** @typedef {bigint} ByteSet */
-/** @typedef {number} Byte */
-/** @type {(n: Byte) => (s: ByteSet) => boolean} */
-export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;
-// create a set
-export const empty = 0n;
-//                        0    1    2    3    4    5    6    7    8    9    A    B    C    D    E    F
-export const universe = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn;
-/** @type {(n: Byte) => ByteSet} */
-export const one = n => 1n << BigInt(n);
-/** @type {(r: readonly[Byte, Byte]) => ByteSet} */
-export const range = ([b, e]) => one(e - b + 1) - 1n << BigInt(b);
-// set operations
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-export const union = a => b => a | b;
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-const intersect = a => b => a & b;
-/** @type {(n: ByteSet) => ByteSet} */
-export const complement = n => universe ^ n;
-/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
-const difference = compose(intersect)(compose(complement));
-// additional operations
-export const set = compose(one)(union);
-export const setRange = compose(range)(union);
-/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
-export const unset = n => s => difference(s)(one(n));
-const counter = reverse(countdown(256));
-/** @type {(n: ByteSet) => (s: string) => (i: number) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
-const toRangeMapOp = n => s => i => {
-    const current = has(i + 1)(n);
-    const prev = has(i)(n);
-    return current === prev ? null : [[prev ? [s] : [], i]];
-};
-/** @type {(n: ByteSet) => (s: string) => RangeMap.RangeMap<SortedSet.SortedSet<string>>} */
-export const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter));

package/out/types/byte_set/test.f.d.mts

@@ -1,13 +0,0 @@
-declare namespace _default {
-    let has: (() => void)[];
-    function setRange(): void;
-    let unset: (() => void)[];
-    function universe(): void;
-    namespace compliment {
-        export function empty(): void;
-        export function universe_1(): void;
-        export { universe_1 as universe };
-    }
-    let toRangeMap: (() => void)[];
-}
-export default _default;

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

@@ -1,123 +0,0 @@
-import * as _ from './module.f.mjs';
-import * as list from '../list/module.f.mjs';
-const { every, countdown, map, toArray } = list;
-import * as json from '../../json/module.f.mjs';
-import * as o from '../object/module.f.mjs';
-const { sort } = o;
-/** @type {(a: readonly json.Unknown[]) => string} */
-const stringify = json.stringify(sort);
-export default {
-    has: [
-        () => {
-            if (_.has(0)(_.empty)) {
-                throw _.empty;
-            }
-            if (_.has(1)(_.empty)) {
-                throw _.empty;
-            }
-            if (_.has(33)(_.empty)) {
-                throw _.empty;
-            }
-        },
-        () => {
-            const s = _.set(0)(_.empty);
-            if (s !== 1n) {
-                throw s;
-            }
-            if (!_.has(0)(s)) {
-                throw s;
-            }
-            if (_.has(1)(s)) {
-                throw s;
-            }
-            if (_.has(33)(s)) {
-                throw s;
-            }
-        },
-        () => {
-            const s = _.set(33)(_.empty);
-            if (s !== 8589934592n) {
-                throw s;
-            }
-            if (_.has(0)(s)) {
-                throw s;
-            }
-            if (_.has(1)(s)) {
-                throw s;
-            }
-            if (!_.has(33)(s)) {
-                throw s;
-            }
-        }
-    ],
-    setRange: () => {
-        const result = _.setRange([2, 5])(_.empty);
-        if (result !== 60n) {
-            throw result;
-        }
-    },
-    unset: [
-        () => {
-            const a = _.set(0)(_.empty);
-            const result = _.unset(0)(a);
-            if (result !== 0n) {
-                throw result;
-            }
-        },
-        () => {
-            const a = _.set(255)(_.empty);
-            const result = _.unset(255)(a);
-            if (result !== 0n) {
-                throw result;
-            }
-        }
-    ],
-    universe: () => {
-        const x = every(map(v => _.has(v)(_.universe))(countdown(256)));
-        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;
-            }
-        },
-    },
-    toRangeMap: [
-        () => {
-            const result = stringify(toArray(_.toRangeMap(_.empty)('a')));
-            if (result !== '[]') {
-                throw result;
-            }
-        },
-        () => {
-            const s = _.set(0)(_.empty);
-            const result = stringify(toArray(_.toRangeMap(s)('a')));
-            if (result !== '[[["a"],0]]') {
-                throw result;
-            }
-        },
-        () => {
-            const s = _.setRange([1, 2])(_.empty);
-            const result = stringify(toArray(_.toRangeMap(s)('a')));
-            if (result !== '[[[],0],[["a"],2]]') {
-                throw result;
-            }
-        },
-        () => {
-            const result = stringify(toArray(_.toRangeMap(_.universe)('a')));
-            if (result !== '[[["a"],255]]') {
-                throw result;
-            }
-        },
-    ]
-};

package/out/types/function/compare/module.f.d.mts

@@ -1,23 +0,0 @@
-/** @typedef {Array.Index3} Index3 */
-/** @typedef {Array.Index5} Index5 */
-/**
- * @template T
- * @typedef {Array.Array2<T>} Array2
- */
-/** @typedef {-1|0|1} Sign */
-/**
- * @template T
- * @typedef {(_: T) => Sign} Compare
- */
-/** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
-export const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
-/** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
-export const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
-/** @type {<T>(a: T) => (b: T) => Sign} */
-export const unsafeCmp: <T>(a: T) => (b: T) => Sign;
-export type Index3 = Array.Index3;
-export type Index5 = Array.Index5;
-export type Array2<T> = Array.Array2<T>;
-export type Sign = -1 | 0 | 1;
-export type Compare<T> = (_: T) => Sign;
-import * as Array from '../../array/module.f.mjs';

package/out/types/function/compare/module.f.mjs

@@ -1,22 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-import * as Array from '../../array/module.f.mjs';
-/** @typedef {Array.Index3} Index3 */
-/** @typedef {Array.Index5} Index5 */
-/**
- * @template T
- * @typedef {Array.Array2<T>} Array2
- */
-/** @typedef {-1|0|1} Sign */
-/**
- * @template T
- * @typedef {(_: T) => Sign} Compare
- */
-/** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
-export const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1);
-/** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
-export const index5 = cmp => ([v0, v1]) => {
-    const _0 = cmp(v0);
-    return /** @type {Index5} */ (_0 <= 0 ? _0 + 1 : cmp(v1) + 3);
-};
-/** @type {<T>(a: T) => (b: T) => Sign} */
-export const unsafeCmp = a => b => a < b ? -1 : a > b ? 1 : 0;

package/out/types/function/compare/test.f.d.mts

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

package/out/types/function/compare/test.f.mjs

@@ -1,8 +0,0 @@
-import * as _ from './module.f.mjs';
-const { unsafeCmp } = _;
-export default () => {
-    const result = unsafeCmp(true)(false);
-    if (result !== 1) {
-        throw result;
-    }
-};

package/out/types/function/module.f.d.mts

@@ -1,51 +0,0 @@
-/**
- * A generic function type.
- *
- * @template I
- * @template O
- * @typedef {(_: I) => O} Func
- */
-/**
- * A postfix compose function.
- *
- * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
- */
-export const compose: <I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>;
-/**
- * A generic identity function.
- *
- * @type {<T>(value: T) => T}
- */
-export const identity: <T>(value: T) => T;
-/**
- * Flips the arguments of a curried function.
- *
- * @type {<A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C}
- */
-export const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C;
-/**
- * A functional utility type that enables seamless chaining of transformations.
- *
- * @template I,O
- * @typedef {{
- *  readonly result: Func<I, O>
- *  readonly then: <T>(g: Func<O, T>) => Fn<I, T>
- * }} Fn
- */
-/**
- * Creates an `Fn` instance from a function, enabling chaining of transformations.
- *
- * @type {<I, O>(f: (i: I) => O) => Fn<I, O>}
- */
-export const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;
-/**
- * A generic function type.
- */
-export type Func<I, O> = (_: I) => O;
-/**
- * A functional utility type that enables seamless chaining of transformations.
- */
-export type Fn<I, O> = {
-    readonly result: Func<I, O>;
-    readonly then: <T>(g: Func<O, T>) => Fn<I, T>;
-};

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

@@ -1,44 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/**
- * A generic function type.
- *
- * @template I
- * @template O
- * @typedef {(_: I) => O} Func
- */
-/**
- * A postfix compose function.
- *
- * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
- */
-export const compose = g => f => x => f(g(x));
-/**
- * A generic identity function.
- *
- * @type {<T>(value: T) => T}
- */
-export const identity = value => value;
-/**
- * Flips the arguments of a curried function.
- *
- * @type {<A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C}
- */
-export const flip = f => b => a => f(a)(b);
-/**
- * A functional utility type that enables seamless chaining of transformations.
- *
- * @template I,O
- * @typedef {{
- *  readonly result: Func<I, O>
- *  readonly then: <T>(g: Func<O, T>) => Fn<I, T>
- * }} Fn
- */
-/**
- * Creates an `Fn` instance from a function, enabling chaining of transformations.
- *
- * @type {<I, O>(f: (i: I) => O) => Fn<I, O>}
- */
-export const fn = result => ({
-    result,
-    then: g => fn(compose(result)(g))
-});

package/out/types/function/operator/module.f.d.mts

@@ -1,60 +0,0 @@
-/**
- * @template A
- * @template B
- * @template R
- * @typedef {(a: A) => (b: B) => R} Binary
- */
-/**
- * @template I,O
- * @typedef {Binary<I, O, O>} Fold
- */
-/** @type {(separator: string) => Reduce<string>} */
-export const join: (separator: string) => Reduce<string>;
-/** @type {Reduce<string>} */
-export const concat: Reduce<string>;
-/**
- * @template T
- * @template R
- * @typedef {(value: T) => R} Unary
- */
-/** @type {Unary<boolean, boolean>} */
-export const logicalNot: Unary<boolean, boolean>;
-/**
- * @template T
- * @typedef {Binary<T, T, boolean>} Equal
- */
-/** @type {<T>(a: T) => (b: T) => boolean} */
-export const strictEqual: <T>(a: T) => (b: T) => boolean;
-/**
- * @template I,O
- * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
- */
-/**
- * @template I,S,O
- * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
- */
-/** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-export const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
-/** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
-export const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
-/**
- * @template T
- * @typedef {Fold<T, T>} Reduce
- */
-/** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
-export const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
-/** @type {Reduce<number>} */
-export const addition: Reduce<number>;
-/** @type {Reduce<number>} */
-export const min: Reduce<number>;
-/** @type {Reduce<number>} */
-export const max: Reduce<number>;
-export const increment: (b: number) => number;
-export function counter(): (b: number) => number;
-export type Binary<A, B, R> = (a: A) => (b: B) => R;
-export type Fold<I, O> = Binary<I, O, O>;
-export type Unary<T, R> = (value: T) => R;
-export type Equal<T> = Binary<T, T, boolean>;
-export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
-export type StateScan<I, S, O> = (prior: S) => (input: I) => readonly [O, S];
-export type Reduce<T> = Fold<T, T>;

package/out/types/function/operator/module.f.mjs

@@ -1,60 +0,0 @@
-// @ts-self-types="./module.f.d.mts"
-/**
- * @template A
- * @template B
- * @template R
- * @typedef {(a: A) => (b: B) => R} Binary
- */
-/**
- * @template I,O
- * @typedef {Binary<I, O, O>} Fold
- */
-/** @type {(separator: string) => Reduce<string>} */
-export const join = separator => value => prior => `${prior}${separator}${value}`;
-/** @type {Reduce<string>} */
-export const concat = i => acc => `${acc}${i}`;
-/**
- * @template T
- * @template R
- * @typedef {(value: T) => R} Unary
- */
-/** @type {Unary<boolean, boolean>} */
-export const logicalNot = v => !v;
-/**
- * @template T
- * @typedef {Binary<T, T, boolean>} Equal
- */
-/** @type {<T>(a: T) => (b: T) => boolean} */
-export const strictEqual = a => b => a === b;
-/**
- * @template I,O
- * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
- */
-/**
- * @template I,S,O
- * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
- */
-/** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-export const stateScanToScan = op => prior => i => {
-    const [o, s] = op(prior)(i);
-    return [o, stateScanToScan(op)(s)];
-};
-/** @type {<I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>} */
-export const foldToScan = fold => prior => i => {
-    const result = fold(i)(prior);
-    return [result, foldToScan(fold)(result)];
-};
-/**
- * @template T
- * @typedef {Fold<T, T>} Reduce
- */
-/** @type {<T>(fold: Reduce<T>) => Scan<T, T>} */
-export const reduceToScan = op => init => [init, foldToScan(op)(init)];
-/** @type {Reduce<number>} */
-export const addition = a => b => a + b;
-/** @type {Reduce<number>} */
-export const min = a => b => a < b ? a : b;
-/** @type {Reduce<number>} */
-export const max = a => b => a > b ? a : b;
-export const increment = addition(1);
-export const counter = () => increment;

package/out/types/function/test.f.d.mts

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

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

@@ -1,15 +0,0 @@
-import * as _ from './module.f.mjs';
-const { fn } = _;
-export default () => {
-    /** @type {(x: string) => readonly[string]} */
-    const f = x => [x];
-    /** @type {(x: readonly[string]) => readonly[number]} */
-    const g = ([x]) => [x.length];
-    /** @type {(x: readonly[number]) => number} */
-    const w = ([x]) => x;
-    const r = fn(f).then(g).then(w).result;
-    const result = r('hello');
-    if (result !== 5) {
-        throw r;
-    }
-};

package/out/types/list/module.f.d.mts

@@ -1,82 +0,0 @@
-/** @type {<T>(head: List<T>) => (tail: List<T>) => List<T>} */
-export const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
-/** @type {<T>(list: List<T>) => Result<T>} */
-export const next: <T>(list: List<T>) => Result<T>;
-/** @type {<T>(list: List<T>) => Iterable<T>} */
-export const iterable: <T>(list: List<T>) => Iterable<T>;
-/** @type {<T>(list: List<T>) => readonly T[]} */
-export const toArray: <T>(list: List<T>) => readonly T[];
-/** @type {<T>(list: List<List<T>>) => Thunk<T>} */
-export const flat: <T>(list: List<List<T>>) => Thunk<T>;
-/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>} */
-export const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
-/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>} */
-export const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-export const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
-/** @type {<I, O>(f: (value: I) => O|null) => (input: List<I>) => Thunk<O>} */
-export const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-export const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
-/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-export const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
-/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>} */
-export const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
-/** @type {(n: number) => <T>(input: List<T>) => Thunk<T>} */
-export const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
-/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
-export const first: <D>(def: D) => <T>(input: List<T>) => D | T;
-/** @type {<D>(first: D) => <T>(tail: List<T>) => D|T} */
-export const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
-/** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
-export const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
-/** @type {(input: List<boolean>) => boolean} */
-export const some: (input: List<boolean>) => boolean;
-/** @type {<T>(input: List<T>) => boolean} */
-export const isEmpty: <T>(input: List<T>) => boolean;
-export const every: function_.Func<List<boolean>, boolean>;
-/** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
-export const includes: <T>(value: T) => (sequence: List<T>) => boolean;
-/** @type {(count: number) => Thunk<number>} */
-export const countdown: (count: number) => Thunk<number>;
-/** @type {<T>(v: T) => (c: number) => Thunk<T>} */
-export const repeat: <T>(v: T) => (c: number) => Thunk<T>;
-/** @type {<T>(list: List<T>) => List<T>} */
-export const cycle: <T>(list: List<T>) => List<T>;
-/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>} */
-export const scan: <I, O>(op: operator.Scan<I, O>) => (input: List<I>) => Thunk<O>;
-/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>} */
-export const stateScan: <I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
-/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>} */
-export const foldScan: <I, O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
-/** @type {<I,O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O} */
-export const fold: <I, O>(op: operator.Fold<I, O>) => (init: O) => (input: List<I>) => O;
-/** @type {<T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D|T} */
-export const reduce: <T>(op: operator.Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
-/** @type {<T>(input: List<T>) => number} */
-export const length: <T>(input: List<T>) => number;
-/** @type {<T>(input: List<T>) => Thunk<Entry<T>>} */
-export const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
-/** @type {<T>(input: List<T>) => List<T>} */
-export const reverse: <T>(input: List<T>) => List<T>;
-/** @type {<A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly[A, B]>} */
-export const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
-/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
-export const equal: <T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
-export const empty: null;
-export type List<T> = NotLazy<T> | Thunk<T>;
-export type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
-export type Empty = null;
-export type Result<T> = Empty | NonEmpty<T>;
-export type Thunk<T> = () => List<T>;
-export type NonEmpty<T> = {
-    readonly first: T;
-    readonly tail: List<T>;
-};
-export type Concat<T> = {
-    readonly head: List<T>;
-    readonly tail: List<T>;
-};
-export type Entry<T> = readonly [number, T];
-import * as function_ from '../function/module.f.mjs';
-import * as operator from '../function/operator/module.f.mjs';