functionalscript 0.43.1 → 0.45.0

package/fjs/types/function/compare/proof.f.js

@@ -1,47 +0,0 @@
-import { cmp, min, max } from './module.f.js';
-import { assertEq } from '../../../asserts/module.f.js';
-export const proof = () => {
-    {
-        const result = cmp(true)(false);
-        assertEq(result, 1);
-        const _ = true < false;
-    }
-    {
-        const result = cmp(1)(2);
-        assertEq(result, -1);
-        const _ = 1 < 2;
-    }
-    {
-        const result = cmp(2n)(-10n);
-        assertEq(result, 1);
-        const _ = 2n < -10n;
-    }
-    {
-        const result = cmp("hello")("hello");
-        assertEq(result, 0);
-        const _ = "hello" < "hello";
-    }
-    {
-        // const result = cmp(true)("hello") // compilation error
-        const a = "hello";
-        const b = 5;
-        // const _ = cmp(a)(b) // compilation error
-        const _ = cmp(a)("hello"); // ??? TypeScript changes a type definition of `a`.
-        // const f = (a: string|number, b: string|number) => cmp(a)(b) // compilation error
-        // const f = (a: number, b: string|number) => cmp(a)(b) // compilation error
-    }
-    {
-        assertEq(min(3)(5), 3, 'min(3)(5)');
-        assertEq(min(7)(2), 2, 'min(7)(2)');
-        assertEq(min(3n)(13n), 3n, 'min(3n)(13n)');
-        assertEq(min("a")("b"), "a", 'min("a")("b")');
-        // const _ = min(1)("a") // compilation error
-    }
-    {
-        assertEq(max(3)(5), 5, 'max(3)(5)');
-        assertEq(max(7)(2), 7, 'max(7)(2)');
-        assertEq(max(3n)(13n), 13n, 'max(3n)(13n)');
-        assertEq(max("a")("b"), "b", 'max("a")("b")');
-        // const _ = max(1)("a") // compilation error
-    }
-};

package/fjs/types/function/module.f.d.ts

@@ -1,28 +0,0 @@
-/**
- * A generic function type.
- */
-export type Func<I, O> = (_: I) => O;
-/**
- * A postfix compose function.
- */
-export declare const compose: <I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>;
-/**
- * A generic identity function.
- */
-export declare const identity: <T>(value: T) => T;
-/**
- * Flips the arguments of a curried function.
- */
-export declare 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.
- */
-type Fn<I, O> = {
-    readonly result: Func<I, O>;
-    readonly map: <T>(g: Func<O, T>) => Fn<I, T>;
-};
-/**
- * Creates an `Fn` instance from a function, enabling chaining of transformations.
- */
-export declare const fn: <I, O>(result: Func<I, O>) => Fn<I, O>;
-export {};

package/fjs/types/function/module.f.js

@@ -1,19 +0,0 @@
-/**
- * A postfix compose function.
- */
-export const compose = g => f => x => f(g(x));
-/**
- * A generic identity function.
- */
-export const identity = value => value;
-/**
- * Flips the arguments of a curried function.
- */
-export const flip = f => b => a => f(a)(b);
-/**
- * Creates an `Fn` instance from a function, enabling chaining of transformations.
- */
-export const fn = (result) => ({
-    result,
-    map: g => fn(compose(result)(g))
-});

package/fjs/types/function/operator/module.f.d.ts

@@ -1,48 +0,0 @@
-/**
- * Common higher-order operator type aliases.
- *
- * @module
- */
-export type Binary<A, B, R> = (a: A) => (b: B) => R;
-export type Fold<I, O> = Binary<I, O, O>;
-export declare const join: (separator: string) => Reduce<string>;
-export declare const concat: Reduce<string>;
-export type Unary<T, R> = (value: T) => R;
-export declare const logicalNot: Unary<boolean, boolean>;
-export type Equal<T> = Binary<T, T, boolean>;
-export declare const strictEqual: <T>(a: T) => (b: T) => boolean;
-export type Scan<I, O> = (input: I) => readonly [O, Scan<I, O>];
-/**
- * One step of a stream transducer: given an `input` symbol and the `prior`
- * state, produce an `output` and the next state. It both maps an input stream
- * to an output stream and threads state, so it models tokenizers, decoders, and
- * other stream-to-stream stages.
- *
- * This is the *shape* of a [Mealy machine](https://en.wikipedia.org/wiki/Mealy_machine)
- * — a [finite-state transducer](https://en.wikipedia.org/wiki/Finite-state_transducer)
- * — but only its signature. The state `S` (and `I`, `O`) is an arbitrary type,
- * not a finite set, so a `StateScan` is strictly more expressive than a Mealy
- * machine — its power is the power of `S`:
- * - a finite `S`/`I`/`O` recovers the classical finite-state machine (e.g. the
- *   DFA states in `../../../fsm/module.f.ts`);
- * - an `S` that is a stack makes it a
- *   [pushdown / stack machine](https://en.wikipedia.org/wiki/Pushdown_automaton)
- *   (context-free power — balanced brackets, nested structure, the AST tier);
- * - an unbounded `S` like `bigint` can count, which no finite automaton can.
- *
- * And `O` may be a list (0+ symbols per input), not the single symbol strict
- * Mealy emits. (Functional/coalgebraic usage still calls this `(input, state)
- * => [output, state]` shape a "Mealy machine", finiteness aside.)
- *
- * A {@link Fold} is the output-less special case (state only); driving a
- * `StateScan` over a `List` is `stateScan` in `../../list/module.f.ts`, and
- * {@link stateScanToScan} hides the state to recover a {@link Scan}.
- */
-export type StateScan<I, S, O> = (input: I, prior: S) => readonly [O, S];
-export declare const stateScanToScan: <I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>;
-export declare const foldToScan: <I, O>(fold: Fold<I, O>) => (prior: O) => Scan<I, O>;
-export type Reduce<T> = Fold<T, T>;
-export declare const reduceToScan: <T>(op: Reduce<T>) => Scan<T, T>;
-export declare const addition: Reduce<number>;
-export declare const increment: (b: number) => number;
-export declare const counter: () => (b: number) => number;

package/fjs/types/function/operator/module.f.js

@@ -1,16 +0,0 @@
-export const join = (separator) => value => prior => `${prior}${separator}${value}`;
-export const concat = i => acc => `${acc}${i}`;
-export const logicalNot = v => !v;
-export const strictEqual = (a) => (b) => a === b;
-export const stateScanToScan = (op) => (prior) => i => {
-    const [o, s] = op(i, prior);
-    return [o, stateScanToScan(op)(s)];
-};
-export const foldToScan = (fold) => (prior) => i => {
-    const result = fold(i)(prior);
-    return [result, foldToScan(fold)(result)];
-};
-export const reduceToScan = (op) => init => [init, foldToScan(op)(init)];
-export const addition = a => b => a + b;
-export const increment = addition(1);
-export const counter = () => increment;

package/fjs/types/function/operator/proof.f.js

@@ -1,53 +0,0 @@
-import { assert, assertEq } from '../../../asserts/module.f.js';
-import { join, concat, logicalNot, strictEqual, addition, increment, counter, stateScanToScan, foldToScan, reduceToScan, } from './module.f.js';
-const joinTest = () => {
-    const result = join(', ')('world')('hello');
-    assertEq(result, 'hello, world');
-};
-const concatTest = () => {
-    const result = concat('world')('hello');
-    assertEq(result, 'helloworld');
-};
-const logicalNotTest = () => {
-    assertEq(logicalNot(true), false, 'expected false');
-    assertEq(logicalNot(false), true, 'expected true');
-};
-const strictEqualTest = () => {
-    assert(strictEqual(1)(1), 'expected true');
-    assert(!(strictEqual(1)(2)), 'expected false');
-};
-const additionTest = () => {
-    const result = addition(3)(4);
-    assertEq(result, 7);
-};
-const incrementTest = () => {
-    assertEq(increment(4), 5, 'increment(4)');
-    assertEq(increment(0), 1, 'increment(0)');
-};
-const foldToScanTest = () => {
-    const scan = foldToScan(addition)(0);
-    const [v1, scan2] = scan(3);
-    assertEq(v1, 3);
-    const [v2] = scan2(4);
-    assertEq(v2, 7);
-};
-const reduceToScanTest = () => {
-    const scan = reduceToScan(addition);
-    const [v0, scan2] = scan(10);
-    assertEq(v0, 10);
-    const [v1] = scan2(5);
-    assertEq(v1, 15);
-};
-const counterTest = () => {
-    const fn = counter();
-    assertEq(fn(4), 5, 'counter() returned wrong function');
-};
-const stateScanToScanTest = () => {
-    const op = (input, state) => [input + state, input + state];
-    const scan = stateScanToScan(op)(0);
-    const [v1, scan2] = scan(3);
-    assertEq(v1, 3);
-    const [v2] = scan2(4);
-    assertEq(v2, 7);
-};
-export const proof = { joinTest, concatTest, logicalNotTest, strictEqualTest, additionTest, incrementTest, counterTest, stateScanToScanTest, foldToScanTest, reduceToScanTest };

package/fjs/types/function/proof.f.js

@@ -1,10 +0,0 @@
-import { fn } from './module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-export const proof = () => {
-    const f = x => [x];
-    const g = ([x]) => [x.length];
-    const w = ([x]) => x;
-    const r = fn(f).map(g).map(w).result;
-    const result = r('hello');
-    assertEq(result, 5, r);
-};

package/fjs/types/list/module.f.d.ts

@@ -1,75 +0,0 @@
-import type { Nullable } from '../nullable/module.f.ts';
-import { type Scan, type StateScan, type Fold, type Reduce, type Equal } from '../function/operator/module.f.ts';
-export type List<T> = NotLazy<T> | Thunk<T>;
-type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
-type Empty = null;
-export type Result<T> = Empty | NonEmpty<T>;
-export type Thunk<T> = () => List<T>;
-/**
- * See also https://en.wikipedia.org/wiki/Cons#Lists
- */
-export type NonEmpty<T> = {
-    readonly first: T;
-    readonly tail: List<T>;
-};
-type Concat<T> = {
-    readonly head: List<T>;
-    readonly tail: List<T>;
-};
-export declare const fromArrayLike: <T>(array: ArrayLike<T>) => Result<T>;
-export declare const concat: <T>(head: List<T>) => (tail: List<T>) => List<T>;
-export declare const next: <T>(head: List<T>) => Result<T>;
-export declare const iterable: <T>(list: List<T>) => Iterable<T>;
-export declare const toArray: <T>(list: List<T>) => readonly T[];
-export declare const flat: <T>(list: List<List<T>>) => Thunk<T>;
-export declare const map: <I, O>(f: (value: I) => O) => (input: List<I>) => Thunk<O>;
-export declare const flatMap: <I, O>(f: (value: I) => List<O>) => (input: List<I>) => Thunk<O>;
-export declare const filter: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
-export declare const filterMap: <I, O>(f: (value: I) => O | null) => (input: List<I>) => Thunk<O>;
-export declare const takeWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
-export declare const take: (n: number) => <T>(input: List<T>) => Thunk<T>;
-export declare const dropWhile: <T>(f: (value: T) => boolean) => (input: List<T>) => Thunk<T>;
-export declare const drop: (n: number) => <T>(input: List<T>) => Thunk<T>;
-export declare const first: <D>(def: D) => <T>(input: List<T>) => D | T;
-export declare const last: <D>(first: D) => <T>(tail: List<T>) => D | T;
-export declare const find: <D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D | T;
-export declare const some: (input: List<boolean>) => boolean;
-export declare const isEmpty: <T>(input: List<T>) => boolean;
-export declare const every: (_: List<boolean>) => boolean;
-export declare const includes: <T>(value: T) => (sequence: List<T>) => boolean;
-export declare const countdown: (count: number) => Thunk<number>;
-export declare const repeat: <T>(v: T) => (c: number) => Thunk<T>;
-export declare const cycle: <T>(list: List<T>) => List<T>;
-export declare const scan: <I, O>(op: Scan<I, O>) => (input: List<I>) => Thunk<O>;
-export declare const stateScan: <I, S, O>(op: StateScan<I, S, O>) => (init: S) => (input: List<I>) => Thunk<O>;
-export declare const foldScan: <I, O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => Thunk<O>;
-export declare const fold: <I, O>(op: Fold<I, O>) => (init: O) => (input: List<I>) => O;
-export declare const reduce: <T>(op: Reduce<T>) => <D>(def: D) => (input: List<T>) => D | T;
-/**
- * A fold that can bail out early, packaged as plain data.
- *
- * `init` is the starting state, `update` advances the state by one item and
- * returns `null` to abort the whole fold, and `end` finalizes the surviving
- * state into a result. Keeping the three parts together lets `tryFold` drive
- * any short-circuiting accumulation without knowing its domain.
- */
-export type Accumulator<I, T, R> = {
-    readonly init: T;
-    readonly update: (i: I, state: T) => Nullable<T>;
-    readonly end: (state: T) => R;
-};
-/**
- * Folds `input` with an {@link Accumulator}, short-circuiting to `null` the
- * moment `update` rejects an item; otherwise finalizes with `end`. This is the
- * list-level `try*` sibling of {@link fold} for accumulations that can fail
- * partway through (see the `try*`/`Nullable` convention in `AGENTS.md`).
- */
-export declare const tryFold: <I, T, R>({ init, update, end }: Accumulator<I, T, R>) => (input: List<I>) => Nullable<R>;
-export declare const length: <T>(input: List<T>) => number;
-export type Entry<T> = readonly [number, T];
-export declare const entries: <T>(input: List<T>) => Thunk<Entry<T>>;
-export declare const reverse: <T>(input: List<T>) => List<T>;
-export declare const zip: <A>(a: List<A>) => <B>(b: List<B>) => Thunk<readonly [A, B]>;
-export declare const equal: <T>(e: Equal<T>) => (a: List<T>) => (b: List<T>) => boolean;
-export declare const empty: null;
-export {};

package/fjs/types/list/module.f.js

@@ -1,190 +0,0 @@
-/**
- * Immutable list data structure utilities and combinators.
- *
- * @module
- */
-import { identity, fn, compose } from '../function/module.f.js';
-import { addition, logicalNot, strictEqual, stateScanToScan, foldToScan, reduceToScan, } from '../function/operator/module.f.js';
-export const fromArrayLike = (array) => {
-    const at = (i) => i < array.length ? { first: array[i], tail: () => at(i + 1) } : null;
-    return at(0);
-};
-export const concat = (head) => (tail) => tail === null ? head : ({ head, tail });
-const trampoline = (list) => {
-    while (typeof list === 'function') {
-        list = list();
-    }
-    return list;
-};
-export const next = (head) => {
-    let tail = null;
-    while (true) {
-        head = trampoline(head);
-        if (head instanceof Array) {
-            head = fromArrayLike(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];
-    }
-};
-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;
-export const toArray = (list) => {
-    const u = trampoline(list);
-    return u instanceof Array ? u : from(iterable(u));
-};
-const apply = (f) => (input) => () => {
-    const n = next(input);
-    return n === null ? null : f(n);
-};
-const flatStep = ({ first, tail }) => concat(first)(flat(tail));
-export const flat = apply(flatStep);
-const mapStep = (f) => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) });
-export const map = f => apply(mapStep(f));
-export const flatMap = f => compose(map(f))(flat);
-const filterStep = f => ({ first, tail }) => {
-    const newTail = filter(f)(tail);
-    return f(first) ? { first, tail: newTail } : newTail;
-};
-export const filter = f => apply(filterStep(f));
-const filterMapStep = f => n => {
-    const [first, tail] = [f(n.first), filterMap(f)(n.tail)];
-    return first === null ? tail : { first, tail };
-};
-export const filterMap = f => apply(filterMapStep(f));
-const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } : null;
-export const takeWhile = f => apply(takeWhileStep(f));
-const takeStep = n => ({ first, tail }) => 0 < n ? { first: first, tail: take(n - 1)(tail) } : null;
-export const take = n => apply(takeStep(n));
-const dropWhileStep = f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne;
-export const dropWhile = f => apply(dropWhileStep(f));
-const dropStep = n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne;
-export const drop = n => apply(dropStep(n));
-export const first = def => input => {
-    const ne = next(input);
-    return ne === null ? def : ne.first;
-};
-export const last = first => tail => {
-    let i = { first, tail };
-    while (true) {
-        const result = next(i.tail);
-        if (result === null) {
-            return i.first;
-        }
-        i = result;
-    }
-};
-export const find = def => f => compose(filter(f))(first(def));
-export const some = find(false)(identity);
-export const isEmpty = fn(map(() => true))
-    .map(some)
-    .map(logicalNot)
-    .result;
-export const every = fn(map(logicalNot))
-    .map(some)
-    .map(logicalNot)
-    .result;
-export const includes = value => compose(map(strictEqual(value)))(some);
-export const countdown = count => () => {
-    if (count <= 0) {
-        return null;
-    }
-    const first = count - 1;
-    return { first, tail: countdown(first) };
-};
-export const repeat = v => compose(countdown)(map(() => v));
-export const cycle = list => () => {
-    const i = next(list);
-    return i === null ? null : { first: i.first, tail: concat(i.tail)(cycle(list)) };
-};
-const scanStep = op => ne => {
-    const [first, newOp] = op(ne.first);
-    return { first, tail: scan(newOp)(ne.tail) };
-};
-export const scan = op => apply(scanStep(op));
-export const stateScan = op => compose(stateScanToScan(op))(scan);
-export const foldScan = op => compose(foldToScan(op))(scan);
-export const fold = op => init => compose(foldScan(op)(init))(last(init));
-export const reduce = op => def => compose(scan(reduceToScan(op)))(last(def));
-/**
- * Folds `input` with an {@link Accumulator}, short-circuiting to `null` the
- * moment `update` rejects an item; otherwise finalizes with `end`. This is the
- * list-level `try*` sibling of {@link fold} for accumulations that can fail
- * partway through (see the `try*`/`Nullable` convention in `AGENTS.md`).
- */
-export const tryFold = ({ init, update, end }) => (input) => {
-    let state = init;
-    for (const i of iterable(input)) {
-        const candidate = update(i, state);
-        if (candidate === null) {
-            return null;
-        }
-        state = candidate;
-    }
-    return end(state);
-};
-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);
-export const length = input => sum(lengthList(input));
-const entryOperator = (value, index) => [[index, value], index + 1];
-export const entries = input => {
-    const o = entryOperator;
-    return stateScan(o)(0)(input);
-};
-const reverseOperator = first => tail => ({ first, tail });
-export const reverse = fold(reverseOperator)(null);
-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) };
-};
-export const equal = e => {
-    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/fjs/types/list/proof.f.d.ts

@@ -1,31 +0,0 @@
-declare const stringifyTest: () => void;
-declare const countdownTest: () => void;
-declare const flatTest: () => void;
-declare const concatTest: () => void;
-declare const flatMapTest: () => void;
-declare const dropWhileTest: () => void;
-declare const logic: () => (() => void)[];
-export declare const proof: {
-    stringifyTest: typeof stringifyTest;
-    cycle: (() => void)[];
-    countdown: typeof countdownTest;
-    flat: typeof flatTest;
-    concat: typeof concatTest;
-    flatMap: typeof flatMapTest;
-    take: (() => void)[];
-    find: (() => void)[];
-    takeWhile: (() => void)[];
-    dropWhile: typeof dropWhileTest;
-    drop: (() => void)[];
-    additionTests: (() => void)[];
-    entries: (() => void)[];
-    tryFold: readonly [() => void, () => void, () => void];
-    reverse: (() => void)[];
-    zip: (() => void)[];
-    logic: typeof logic;
-    strictEqual: (() => void)[];
-    isEmpty: (() => void)[];
-    length: () => void;
-    filterMap: (() => void)[];
-};
-export {};