functionalscript 0.43.0 → 0.44.0

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

@@ -1,77 +0,0 @@
-import { join, concat, repeat, cmp, splitAt } from './module.f.js';
-import { repeat as repeatList } from '../list/module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    example: () => {
-        const words = ['hello', 'world'];
-        assertEq(join(' ')(words), 'hello world', 0);
-        assertEq(concat(words), 'helloworld', 1);
-        assertEq(repeat('abc')(3), 'abcabcabc', 2);
-        assertEq(cmp('apple')('banana'), -1, 3);
-    },
-    join: {
-        0: () => {
-            const result = join('/')([]);
-            assertEq(result, '');
-        },
-        1: () => {
-            const result = join('/')(['']);
-            assertEq(result, '');
-        },
-        3: () => {
-            const result = join(' ')(['hello', 'world', '!']);
-            assertEq(result, 'hello world !');
-        }
-    },
-    concat: () => {
-        const result = concat(['hello', 'world']);
-        assertEq(result, 'helloworld');
-    },
-    repeatList: {
-        0: () => {
-            const s = join('.')(repeatList('x')(0));
-            assert(s == '', s);
-        },
-        5: () => {
-            const s = join('.')(repeatList('x')(5));
-            assert(s == 'x.x.x.x.x', s);
-        }
-    },
-    repeat: () => {
-        const s = repeat('x')(5);
-        if (s != 'xxxxx') {
-            throw s;
-        }
-    },
-    cmp: () => {
-        const result = cmp('3')('4');
-        assertEq(result, -1);
-    },
-    splitAt: {
-        middle: () => {
-            const [a, b] = splitAt(3)('hello');
-            assertEq(a, 'hel');
-            assertEq(b, 'lo');
-        },
-        zero: () => {
-            const [a, b] = splitAt(0)('hello');
-            assertEq(a, '');
-            assertEq(b, 'hello');
-        },
-        full: () => {
-            const [a, b] = splitAt(5)('hello');
-            assertEq(a, 'hello');
-            assertEq(b, '');
-        },
-        beyond: () => {
-            const [a, b] = splitAt(10)('hello');
-            assertEq(a, 'hello');
-            assertEq(b, '');
-        },
-        empty: () => {
-            const [a, b] = splitAt(0)('');
-            assertEq(a, '');
-            assertEq(b, '');
-        },
-    }
-};

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

@@ -1,30 +0,0 @@
-/**
- * A set of strings implemented as a B-Tree.
- *
- * @module
- *
- * @example
- *
- * ```js
- * import { set, contains, remove, fromValues, values, empty } from './module.d.ts';
- *
- * let mySet = fromValues(['apple', 'banana', 'cherry']);
- * if (!contains('banana')(mySet)) { throw '1' }
- * if (contains('date')(mySet)) { throw '2' }
- *
- * mySet = set('date')(mySet);
- * if (!contains('date')(mySet)) { throw '3' }
- *
- * mySet = remove('banana')(mySet);
- * if (contains('banana')(mySet)) { throw '4' }
- * ```
- */
-import type { Tree } from '../btree/types/module.f.ts';
-import { type List } from '../list/module.f.ts';
-export declare const values: (s: StringSet) => List<string>;
-export declare const empty: null;
-export type StringSet = Tree<string>;
-export declare const contains: (value: string) => (set: StringSet) => boolean;
-export declare const set: (value: string) => (s: StringSet) => StringSet;
-export declare const fromValues: (input: List<string>) => StringSet;
-export declare const remove: (value: string) => (s: StringSet) => StringSet;

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

@@ -1,37 +0,0 @@
-/**
- * A set of strings implemented as a B-Tree.
- *
- * @module
- *
- * @example
- *
- * ```js
- * import { set, contains, remove, fromValues, values, empty } from './module.d.ts';
- *
- * let mySet = fromValues(['apple', 'banana', 'cherry']);
- * if (!contains('banana')(mySet)) { throw '1' }
- * if (contains('date')(mySet)) { throw '2' }
- *
- * mySet = set('date')(mySet);
- * if (!contains('date')(mySet)) { throw '3' }
- *
- * mySet = remove('banana')(mySet);
- * if (contains('banana')(mySet)) { throw '4' }
- * ```
- */
-import { empty as btEmpty, values as btValues } from '../btree/module.f.js';
-import { find, isFound } from '../btree/find/module.f.js';
-import { remove as btreeRemove } from '../btree/remove/module.f.js';
-import { set as btreeSet } from '../btree/set/module.f.js';
-import { cmp } from "../string/module.f.js";
-import { fold } from '../list/module.f.js';
-import { compose } from '../function/module.f.js';
-export const values = btValues;
-export const empty = btEmpty;
-export const contains = value => {
-    const f = find(cmp(value));
-    return s => s !== null && isFound(f(s).first);
-};
-export const set = value => btreeSet(cmp(value))(() => value);
-export const fromValues = fold(set)(null);
-export const remove = compose(cmp)(btreeRemove);

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

@@ -1,43 +0,0 @@
-import { contains, fromValues, remove, set } from './module.f.js';
-import { assert, assertEq } from '../../asserts/module.f.js';
-export const proof = {
-    example: () => {
-        let mySet = fromValues(['apple', 'banana', 'cherry']);
-        assert(contains('banana')(mySet), '1');
-        assert(!(contains('date')(mySet)), '2');
-        mySet = set('date')(mySet);
-        assert(contains('date')(mySet), '3');
-        mySet = remove('banana')(mySet);
-        assert(!(contains('banana')(mySet)), '4');
-    },
-    contains: () => {
-        const r = set('hello')(null);
-        assert(contains('hello')(r), r);
-        assert(!(contains('hello1')(r)), r);
-    },
-    remove: () => {
-        let r = set('hello')(null);
-        r = set('world')(r);
-        r = set('HELLO')(r);
-        r = set('WORLD!')(r);
-        assert(contains('hello')(r), r);
-        assert(!(contains('hello1')(r)), r);
-        assert(contains('HELLO')(r), r);
-        assert(!(contains('WORLD')(r)), r);
-        assert(contains('world')(r), r);
-        assert(!(contains('world!')(r)), r);
-        assert(contains('WORLD!')(r), r);
-        //
-        r = remove('hello')(r);
-        assert(!(contains('hello')(r)), r);
-        assert(contains('world')(r), r);
-        r = remove('world')(r);
-        assert(!(contains('world')(r)), r);
-        assert(contains('HELLO')(r), r);
-        r = remove('HELLO')(r);
-        assert(!(contains('HELLO')(r)), r);
-        assert(contains('WORLD!')(r), r);
-        r = remove('WORLD!')(r);
-        assertEq(r, null);
-    }
-};

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

@@ -1,23 +0,0 @@
-/**
- * TypeScript source-emitter helpers: the `Equal`/`Assert` compile-time
- * predicates and a `Printer` that renders tuples, structs, arrays, records,
- * primitive literals, and unions as TypeScript type expressions.
- *
- * @module
- */
-export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
-/** Functions for emitting TypeScript type expression strings. */
-export type Printer = {
-    /** Emits a tuple type: `readonly[A, B]` or `[A, B]` when mutable. */
-    readonly tuple: (types: readonly string[]) => string;
-    /** Emits an object type with named fields: `{readonly"k":T}` or `{"k":T}` when mutable. */
-    readonly struct: (fields: readonly (readonly [string, string])[]) => string;
-    /** Emits an array type: `readonly(T)[]` or `(T)[]` when mutable. */
-    readonly array: (type: string) => string;
-    /** Emits an index-signature record type: `{readonly[k in string]?:T}` or `{[k in string]?:T}` when mutable. */
-    readonly record: (type: string) => string;
-};
-/** Creates a `Printer`. Pass `true` to emit mutable (non-`readonly`) types. */
-export declare const printer: (mut?: true) => Printer;
-export declare const primitive: (c: bigint | string | undefined | boolean | number | null) => string;
-export declare const union: (types: readonly string[]) => string;

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

@@ -1,27 +0,0 @@
-const complex = (open, close) => (i) => `${open}${i.join(',')}${close}`;
-const structX = complex('{', '}');
-/** Creates a `Printer`. Pass `true` to emit mutable (non-`readonly`) types. */
-export const printer = (mut) => {
-    const ro = mut ? '' : 'readonly';
-    return {
-        tuple: (mut ? complex('[', ']') : complex('readonly[', ']')),
-        struct: (fields) => structX(fields.map(([k, v]) => `${ro}${JSON.stringify(k)}:${v}`)),
-        array: (type) => `${ro}(${type})[]`,
-        // `[k:string]?:` is invalid TypeScript — optional keys on an infinite
-        // key set require mapped-type syntax.
-        record: (type) => structX([`${ro}[k in string]?:${type}`]),
-    };
-};
-export const primitive = (c) => {
-    if (c === null) {
-        return 'null';
-    }
-    switch (typeof c) {
-        case 'bigint': return `${c}n`;
-        case 'string': return JSON.stringify(c);
-        case 'number': return isFinite(c) ? String(c) : 'number';
-        case 'undefined':
-        case 'boolean': return String(c);
-    }
-};
-export const union = (types) => types.length === 0 ? 'never' : types.join('|');

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

@@ -1,86 +0,0 @@
-import { printer, primitive, union } from './module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
-const ro = printer();
-const mut = printer(true);
-export const primitiveNull = () => {
-    const r = primitive(null);
-    assertEq(r, 'null');
-};
-export const primitiveBigint = () => {
-    const r = primitive(42n);
-    assertEq(r, '42n');
-};
-export const primitiveString = () => {
-    const r = primitive('hello');
-    assertEq(r, '"hello"');
-};
-export const primitiveNumberFinite = () => {
-    const r = primitive(3.14);
-    assertEq(r, '3.14');
-};
-export const primitiveNumberInfinite = () => {
-    const r = primitive(Infinity);
-    assertEq(r, 'number');
-};
-export const primitiveUndefined = () => {
-    const r = primitive(undefined);
-    assertEq(r, 'undefined');
-};
-export const primitiveBoolean = () => {
-    const r = primitive(true);
-    assertEq(r, 'true');
-};
-export const unionEmpty = () => {
-    const r = union([]);
-    assertEq(r, 'never');
-};
-export const unionSingle = () => {
-    const r = union(['string']);
-    assertEq(r, 'string');
-};
-export const unionMulti = () => {
-    const r = union(['string', 'number']);
-    assertEq(r, 'string|number');
-};
-export const printerReadonlyTuple = () => {
-    const r = ro.tuple(['string', 'number']);
-    assertEq(r, 'readonly[string,number]');
-};
-export const printerReadonlyStruct = () => {
-    const r = ro.struct([['x', 'number'], ['y', 'string']]);
-    if (r !== '{readonly"x":number,readonly"y":string}') {
-        throw r;
-    }
-};
-export const printerReadonlyArray = () => {
-    const r = ro.array('string');
-    assertEq(r, 'readonly(string)[]');
-};
-export const printerReadonlyRecord = () => {
-    const r = ro.record('number');
-    if (r !== '{readonly[k in string]?:number}') {
-        throw r;
-    }
-};
-export const printerMutableTuple = () => {
-    const r = mut.tuple(['string', 'number']);
-    assertEq(r, '[string,number]');
-};
-export const printerMutableStruct = () => {
-    const r = mut.struct([['x', 'number']]);
-    if (r !== '{"x":number}') {
-        throw r;
-    }
-};
-export const printerMutableArray = () => {
-    const r = mut.array('string');
-    assertEq(r, '(string)[]');
-};
-export const printerMutableRecord = () => {
-    const r = mut.record('number');
-    if (r !== '{[k in string]?:number}') {
-        throw r;
-    }
-};
-export const proof = { primitiveNull, primitiveBigint, primitiveString, primitiveNumberFinite, primitiveNumberInfinite, primitiveUndefined, primitiveBoolean, unionEmpty, unionSingle, unionMulti, printerReadonlyTuple, printerReadonlyStruct, printerReadonlyArray, printerReadonlyRecord, printerMutableTuple, printerMutableStruct, printerMutableArray, printerMutableRecord };
-// type T4 = {[k:string]?: bigint} //< compilation error.

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

@@ -1,13 +0,0 @@
-import { type Vec } from '../bit_vec/module.f.ts';
-import { type List } from '../list/module.f.ts';
-/**
- * Converts a Uint8Array into an MSB-first bit vector.
- */
-export declare const toVec: (input: Uint8Array) => Vec;
-export declare const listToVec: (input: List<Uint8Array>) => Vec;
-/**
- * Converts an MSB-first bit vector into a Uint8Array.
- */
-export declare const fromVec: (input: Vec) => Uint8Array;
-export declare const decodeUtf8: (input: Uint8Array) => string;
-export declare const encodeUtf8: (input: string) => Uint8Array;

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

@@ -1,34 +0,0 @@
-/**
- * Conversions between `Uint8Array` values and bit vectors.
- *
- * @deprecated FunctionalScript represents byte data as `bigint`-based bit
- * vectors (`Vec` from `fjs/types/bit_vec`). Use `utf8`/`utf8ToString` from
- * `fjs/text` for string encoding, and the `bit_vec` module directly for raw
- * byte manipulation. `Uint8Array` interop belongs at Node.js boundaries only
- * (e.g. `fromVec`/`toVec` when reading or writing files).
- *
- * @module
- */
-import { assert, assertNotNullish } from '../../asserts/module.f.js';
-import { utf8, utf8ToString } from '../../text/module.f.js';
-import { maxLengthBytes, msb, tryU8ListToVec, u8List, u8ListToVec } from '../bit_vec/module.f.js';
-import { compose } from '../function/module.f.js';
-import { flat, fromArrayLike, iterable, map } from '../list/module.f.js';
-const u8ListToVecMsb = u8ListToVec(msb);
-const tryU8ListToVecMsb = tryU8ListToVec(msb);
-const u8ListMsb = u8List(msb);
-/**
- * Converts a Uint8Array into an MSB-first bit vector.
- */
-export const toVec = (input) => {
-    assert(input.length <= maxLengthBytes, "the array is too big");
-    return u8ListToVecMsb(fromArrayLike(input));
-};
-const m = map(fromArrayLike);
-export const listToVec = (input) => assertNotNullish(tryU8ListToVecMsb(flat(m(input))), "the array is too big");
-/**
- * Converts an MSB-first bit vector into a Uint8Array.
- */
-export const fromVec = (input) => Uint8Array.from(iterable(u8ListMsb(input)));
-export const decodeUtf8 = compose(toVec)(utf8ToString);
-export const encodeUtf8 = compose(utf8)(fromVec);

package/fjs/types/uint8array/proof.f.d.ts

@@ -1,17 +0,0 @@
-export declare const proof: {
-    empty: () => void;
-    roundTrip: () => void;
-    unalignedLength: () => void;
-    encodeUtf8Empty: () => void;
-    encodeUtf8Ascii: () => void;
-    encodeUtf8Multibyte: () => void;
-    decodeUtf8Ascii: () => void;
-    decodeUtf8Multibyte: () => void;
-    utf8RoundTrip: () => void;
-    listToVec: () => void;
-    maxLength: () => import("../bit_vec/module.f.ts").Vec;
-    throw: {
-        toVec: () => import("../bit_vec/module.f.ts").Vec;
-        listToVec: () => import("../bit_vec/module.f.ts").Vec;
-    };
-};

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

@@ -1,64 +0,0 @@
-import { maxLength, maxLengthBytes, vec } from '../bit_vec/module.f.js';
-import { toVec, fromVec, listToVec, decodeUtf8, encodeUtf8 } from './module.f.js';
-import { strictEqual } from '../function/operator/module.f.js';
-import { equal, fromArrayLike } from '../list/module.f.js';
-import { assert } from '../../asserts/module.f.js';
-const assertEq = (a, b) => {
-    assert(a === b, [a, b]);
-};
-const assertArrayEq = (a, b) => {
-    assert(equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b)), [a, b]);
-};
-export const proof = {
-    empty: () => {
-        const input = new Uint8Array();
-        const vec = toVec(input);
-        const output = fromVec(vec);
-        assertArrayEq(output, input);
-    },
-    roundTrip: () => {
-        const input = Uint8Array.from([0, 1, 2, 3, 255]);
-        const vec = toVec(input);
-        const output = fromVec(vec);
-        assertArrayEq(output, input);
-    },
-    unalignedLength: () => {
-        const input = vec(4n)(0xfn);
-        const output = fromVec(input);
-        assertArrayEq(output, Uint8Array.from([0xF0]));
-    },
-    encodeUtf8Empty: () => {
-        const output = encodeUtf8('');
-        assertArrayEq(output, new Uint8Array());
-    },
-    encodeUtf8Ascii: () => {
-        const output = encodeUtf8('Hi!');
-        assertArrayEq(output, Uint8Array.from([72, 105, 33]));
-    },
-    encodeUtf8Multibyte: () => {
-        const output = encodeUtf8('✓');
-        assertArrayEq(output, Uint8Array.from([0xE2, 0x9C, 0x93]));
-    },
-    decodeUtf8Ascii: () => {
-        const output = decodeUtf8(Uint8Array.from([102, 115]));
-        assertEq(output, 'fs');
-    },
-    decodeUtf8Multibyte: () => {
-        const output = decodeUtf8(Uint8Array.from([0xE2, 0x9C, 0x93]));
-        assertEq(output, '✓');
-    },
-    utf8RoundTrip: () => {
-        const input = 'FunctionalScript 🐝';
-        const output = decodeUtf8(encodeUtf8(input));
-        assertEq(output, input);
-    },
-    listToVec: () => {
-        const result = listToVec([Uint8Array.from([1, 2]), Uint8Array.from([3])]);
-        assertArrayEq(fromVec(result), Uint8Array.from([1, 2, 3]));
-    },
-    maxLength: () => toVec(new Uint8Array(Number(maxLengthBytes))),
-    throw: {
-        toVec: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
-        listToVec: () => listToVec([new Uint8Array(Number(maxLengthBytes)), Uint8Array.from([0])]),
-    },
-};

package/fjs/website/module.f.d.ts

@@ -1,3 +0,0 @@
-import { type WriteFile } from '../effects/node/module.f.ts';
-import { type Effect } from '../effects/module.f.ts';
-export declare const main: () => Effect<WriteFile, number>;

package/fjs/website/module.f.js

@@ -1,14 +0,0 @@
-/**
- * Static website generation program for project landing content.
- *
- * @module
- */
-import { htmlUtf8 } from '../media/html/module.f.js';
-import { writeFile } from '../effects/node/module.f.js';
-import { pure, step } from '../effects/module.f.js';
-const html = htmlUtf8()(['a',
-    { href: 'https://github.com/functionalscript/functionalscript' },
-    'GitHub Repository'
-]);
-const program = step(writeFile('index.html', html), () => pure(0));
-export const main = () => program;

package/fjs/website/proof.f.js

@@ -1,13 +0,0 @@
-import { main } from './module.f.js';
-import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
-import { assertEq, assertNotNullish } from '../asserts/module.f.js';
-export const proof = {
-    main: () => {
-        assertNotNullish(main(), 'expected a program effect');
-    },
-    run: () => {
-        const state = { ...emptyState, root: { '.github': { workflows: {} } } };
-        const [_, result] = virtual(state)(main());
-        assertEq(result, 0);
-    },
-};

package/nanvm-lib/tests/proof.f.d.ts

@@ -1,122 +0,0 @@
-export declare const proof: {
-    eq: () => {
-        nullish: () => void;
-        boolean: {
-            boolean: () => void;
-            nullish: () => void;
-        };
-        number: {
-            number: () => void;
-            nullish: () => void;
-        };
-        string: {
-            string: () => void;
-            number: () => void;
-        };
-        bigint: {
-            bigint: () => void;
-        };
-        array: {
-            array: () => void;
-        };
-        object: {
-            object: () => void;
-        };
-    };
-    unary_plus: () => {
-        null: () => void;
-        undefined: () => void;
-        boolean: {
-            false: () => void;
-            true: () => void;
-        };
-        number: {
-            zero: () => void;
-            positive: () => void;
-            negative: () => void;
-        };
-        string: {
-            empty: () => void;
-            zero: () => void;
-            positive: () => void;
-            nan: () => void;
-        };
-        bigint: {
-            throw: () => number;
-        };
-        array: {
-            empty: () => void;
-            single_number: () => void;
-            single_string: () => void;
-            multiple: () => void;
-        };
-        object: {
-            empty: () => void;
-        };
-        function: () => void;
-    };
-    unary_minus: () => {
-        null: () => void;
-        undefined: () => void;
-        boolean: {
-            false: () => void;
-            true: () => void;
-        };
-        number: {
-            zero: () => void;
-            positive: () => void;
-            negative: () => void;
-        };
-        string: {
-            empty: () => void;
-            zero: () => void;
-            positive: () => void;
-            nan: () => void;
-        };
-        bigint: {
-            positive: () => void;
-            negative: () => void;
-        };
-        array: {
-            empty: () => void;
-            single_number: () => void;
-            single_string: () => void;
-            multiple: () => void;
-        };
-        object: {
-            empty: () => void;
-        };
-        function: () => void;
-    };
-    mul: () => {
-        nullish: () => void;
-        boolean: () => void;
-        number: () => void;
-        bigint: () => void;
-        string: () => void;
-        array: () => void;
-        object: () => void;
-    };
-    stringCoercion: {
-        number: () => void;
-        bool: () => void;
-        null: () => void;
-        undefined: () => void;
-        bigint: () => void;
-        array: () => void;
-        func: () => void;
-        object: {
-            norm: () => void;
-            toString: () => void;
-            toStringThrow: {
-                throw: () => void;
-            };
-            toStringNotFunc: {
-                throw: () => void;
-            };
-            toStringNonPrimitive: {
-                throw: () => void;
-            };
-        };
-    };
-};