functionalscript 0.2.0 → 0.2.1

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/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/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/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.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;