functionalscript 0.1.609 → 0.2.1

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

@@ -0,0 +1,42 @@
+// @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.mjs

@@ -0,0 +1,123 @@
+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/{types → out/types}/function/compare/module.f.d.mts

@@ -1,16 +1,3 @@
-declare namespace _default {
-    export { unsafeCmp };
-    export { index3 };
-    export { index5 };
-}
-export default _default;
-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;
-/** @type {<T>(a: T) => (b: T) => Sign} */
-declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
 /** @typedef {Array.Index3} Index3 */
 /** @typedef {Array.Index5} Index5 */
 /**
@@ -23,7 +10,14 @@ declare const unsafeCmp: <T>(a: T) => (b: T) => Sign;
  * @typedef {(_: T) => Sign} Compare
  */
 /** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
-declare const index3: <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} */
-declare const index5: <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

@@ -0,0 +1,22 @@
+// @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.mjs

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

package/{types → out/types}/function/module.f.d.mts

@@ -1,27 +1,3 @@
-declare namespace _default {
-    export { identity };
-    export { compose };
-    export { flip };
-    export { fn };
-}
-export default _default;
-/**
- * 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>;
-};
-/**
- * A generic identity function.
- *
- * @type {<T>(value: T) => T}
- */
-declare const identity: <T>(value: T) => T;
 /**
  * A generic function type.
  *
@@ -34,13 +10,19 @@ declare const identity: <T>(value: T) => T;
  *
  * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>}
  */
-declare const compose: <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}
  */
-declare const flip: <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.
  *
@@ -55,4 +37,15 @@ declare const flip: <A, B, C>(f: (a: A) => (b: B) => C) => (b: B) => (a: A) => C
  *
  * @type {<I, O>(f: (i: I) => O) => Fn<I, O>}
  */
-declare const fn: <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

@@ -0,0 +1,44 @@
+// @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/{types → out/types}/function/operator/module.f.d.mts

@@ -1,25 +1,3 @@
-declare namespace _default {
-    export { join };
-    export { addition };
-    export { increment };
-    export { strictEqual };
-    export { logicalNot };
-    export { min };
-    export { max };
-    export { stateScanToScan };
-    export { foldToScan };
-    export { reduceToScan };
-    export { counter };
-    export { concat };
-}
-export default _default;
-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>;
 /**
  * @template A
  * @template B
@@ -31,27 +9,22 @@ export type Reduce<T> = Fold<T, T>;
  * @typedef {Binary<I, O, O>} Fold
  */
 /** @type {(separator: string) => Reduce<string>} */
-declare const join: (separator: string) => Reduce<string>;
-/** @type {Reduce<number>} */
-declare const addition: Reduce<number>;
-declare const increment: (b: number) => number;
-/**
- * @template T
- * @typedef {Binary<T, T, boolean>} Equal
- */
-/** @type {<T>(a: T) => (b: T) => boolean} */
-declare const strictEqual: <T>(a: T) => (b: T) => boolean;
+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>} */
-declare const logicalNot: Unary<boolean, boolean>;
-/** @type {Reduce<number>} */
-declare const min: Reduce<number>;
-/** @type {Reduce<number>} */
-declare const max: Reduce<number>;
+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
@@ -61,15 +34,27 @@ declare const max: Reduce<number>;
  * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
  */
 /** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
-declare const stateScanToScan: <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>} */
-declare const foldToScan: <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>} */
-declare const reduceToScan: <T>(fold: Reduce<T>) => Scan<T, T>;
-declare function counter(): (b: number) => number;
-/** @type {Reduce<string>} */
-declare const concat: Reduce<string>;
+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

@@ -0,0 +1,60 @@
+// @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.mjs

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,82 @@
+/** @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';