functionalscript 0.37.0 → 0.39.0

package/fs/djs/tokenizer-new/module.f.js

@@ -1,155 +0,0 @@
-/**
- * Experimental DJS parser implementation.
- *
- * @module
- */
-import { descentParser } from "../../bnf/descent/module.f.js";
-import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
-import { todo } from "../../asserts/module.f.js";
-export const parse = (input) => {
-    const m = descentParser(jsGrammar());
-    return todo();
-};
-export const jsGrammar = () => {
-    const onenine = range('19');
-    const digit = range('09');
-    const string = [
-        '"',
-        repeat0Plus({
-            ...remove(range(` ${max}`), set('"\\')),
-            escape: [
-                '\\',
-                {
-                    ...set('"\\bfnrt'),
-                    solidus: '/',
-                    u: [
-                        'u',
-                        ...repeat(4)({
-                            digit,
-                            AF: range('AF'),
-                            af: range('af'),
-                        })
-                    ],
-                }
-            ],
-        }),
-        '"'
-    ];
-    const digits0 = repeat0Plus(digit);
-    const digits = [digit, digits0];
-    const number = [
-        {
-            0: '0',
-            onenine: [onenine, digits0],
-        },
-        option({
-            bigint: 'n',
-            frac: [
-                option(['.', digits]),
-                option([set('Ee'), option(set('+-')), digits])
-            ]
-        })
-    ];
-    const ws = set(' \t');
-    const newLine = set('\n\r');
-    const idStart = {
-        smallLetter: range('az'),
-        bigLetter: range('AZ'),
-        lowLine: '_',
-        dollarSign: '$'
-    };
-    const idChar = {
-        ...idStart,
-        digit
-    };
-    const id = [idStart, repeat0Plus(idChar)];
-    const operator = {
-        '.': '.',
-        '=>': '=>',
-        '===': '===',
-        '==': '==',
-        '=': '=',
-        '!==': '!==',
-        '!=': '!=',
-        '!': '!',
-        '>>>=': '>>>=',
-        '>>>': '>>>',
-        '>>=': '>>=',
-        '>>': '>>',
-        '>=': '>=',
-        '>': '>',
-        '<<<<=': '<<<=',
-        '<<<': '<<<',
-        '<<=': '<<=',
-        '<<': '<<',
-        '<=': '<=',
-        '<': '<',
-        '+=': '+=',
-        '++': '++',
-        '+': '+',
-        '-=': '-=',
-        '--': '--',
-        '-': '-',
-        '**=': '**=',
-        '**': '**',
-        '*=': '*=',
-        '*': '*',
-        '/=': '/=',
-        '/': '/',
-        '%=': '%=',
-        '%': '%',
-        '&&=': '&&=',
-        '&&': '&&',
-        '&=': '&=',
-        '&': '&',
-        '||=': '||=',
-        '||': '||',
-        '|=': '|=',
-        '|': '|',
-        '^=': '^=',
-        '^': '^',
-        '~': '~',
-        '??=': '??=',
-        '??': '??',
-        '?.': '?.',
-        '?': '?',
-        '[': '[',
-        ']': ']',
-        '{': '{',
-        '}': '}',
-        '(': '(',
-        ')': ')',
-        ',': ',',
-        ':': ':'
-    };
-    const commentEnd = {
-        ...newLine,
-        eof
-    };
-    const comment = ['/', {
-            // TODO: investigate why `not(commentEnd)` instead of `remove(unicodeRange, newLine)` fail tests.
-            // TODO: should it be `repeat0Plus(not(commentEnd))` instead of `option(remove(unicodeRange, newLine))`.
-            oneline: ['/', option(remove(unicodeRange, newLine)), commentEnd],
-            multiline: [
-                '*',
-                repeat0Plus({
-                    na: notSet('*'),
-                    a: ['*', notSet('/')]
-                }),
-                '*/'
-            ]
-        }
-    ];
-    const token = {
-        number,
-        string,
-        id,
-        comment,
-        operator,
-        ws,
-        newLine,
-        eof
-    };
-    const tokens = repeat0Plus(token);
-    return tokens;
-};

package/fs/effects/module.f.d.ts

@@ -1,106 +0,0 @@
-/**
- * Core effect type constructors and combinators.
- *
- * Effect helpers are **step adapters**: functions that return a continuation
- * `(t: T) => Effect<Q, R>` meant to be passed into `.step`, never wrappers
- * that take the effect itself as an argument. `Effect` has no pipeline
- * operator to lean on and must not be extended with new methods, so
- * `.step(adapterA).step(adapterB)` is how helpers compose — flat,
- * left-to-right, in evaluation order. See {@link okStep} for an example.
- *
- * @module
- */
-import { type List } from '../types/list/module.f.ts';
-import type { Result } from '../types/result/module.f.ts';
-export type Operation = readonly [string, (..._: readonly never[]) => unknown];
-export type Effect<O extends Operation, T> = {
-    value: Value<O, T>;
-    step: <Q extends Operation, R>(f: (p: T) => Effect<Q, R>) => Effect<O | Q, R>;
-};
-export type Value<O extends Operation, T> = Pure<T> | Do<O, T>;
-export type Pure<T> = () => T;
-export type DoKPR<O extends Operation, T, K extends string, PR extends readonly [unknown, unknown]> = readonly [K, PR[0], (_: PR[1]) => Effect<O, T>];
-export type Pr<O extends Operation, K extends O[0]> = O extends readonly [K, (...args: infer P) => infer R] ? readonly [P, R] : never;
-export type DoK<O extends Operation, T, K extends O[0]> = DoKPR<O, T, K, Pr<O, K>>;
-export type Do<O extends Operation, T> = DoK<O, T, O[0]>;
-export declare const pure: <T>(v: T) => Effect<never, T>;
-/**
- * A lazy pure effect. Like {@link pure}, but takes a thunk and evaluates it on
- * demand instead of holding an already-computed value. Use this to produce the
- * next item of a list without instantiating the rest — the thunk runs only when
- * the effect is decoded (or stepped into).
- */
-export declare const lazy: <T>(t: () => T) => Effect<never, T>;
-export declare const doFull: <O extends Operation, T, K extends O[0]>(cmd: K, param: Pr<O, K>[0], cont: (input: Pr<O, K>[1]) => Effect<O, T>) => Effect<O, T>;
-export type Param<O extends Operation> = F<O>[0];
-export type Return<O extends Operation> = F<O>[1];
-export declare const do_: <O extends Operation>(cmd: O[0]) => (...param: Param<O>) => Effect<O, Return<O>>;
-/**
- * Sequentially threads a state value through an effect for each item in `items`.
- *
- * Given `f: item => state => Effect<O, state>`, `init: S`, and `items: [x₀, x₁, …]`,
- * builds `f(x₀)(init).step(f(x₁)).step(f(x₂)).…` and yields a single
- * `Effect<O, S>` that produces the final state.
- *
- * Sequential — each step depends on the previous state. Compare to `all`,
- * which fans out independent effects.
- */
-export declare const foldStep: <O extends Operation, T, S>(f: (item: T) => (state: S) => Effect<O, S>) => (init: S) => (items: List<T>) => Effect<O, S>;
-/**
- * Sequentially runs `f(item)` for each item in `items`, discarding intermediate
- * results. The `void` accumulator sibling of `foldStep`.
- */
-export declare const forEachStep: <O extends Operation, T>(f: (item: T) => Effect<O, void>) => (items: List<T>) => Effect<O, void>;
-/**
- * A step adapter for the `error` short-circuit: `error` → pass it through
- * unchanged as `pure`, `ok` → continue with `f`. Collapses the hand-written
- * `r[0] === 'error' ? pure(r) : f(r[1])` check that recurs at every site
- * chaining `Effect<O, Result<T, E>>` steps.
- */
-export declare const okStep: <T, E, O extends Operation, R>(f: (value: T) => Effect<O, Result<R, E>>) => (r: Result<T, E>) => Effect<O, Result<R, E>>;
-/**
- * The decoded form of an effect's next step: either a final `result`, or a
- * `command` to perform with its `payload` and the `continuation` to resume
- * with the command's output.
- */
-export type Decoded<O extends Operation, T> = {
-    readonly done: true;
-    readonly result: T;
-} | {
-    readonly done: false;
-    readonly command: Do<O, T>[0];
-    readonly payload: Do<O, T>[1];
-    readonly continuation: Do<O, T>[2];
-};
-/**
- * Decodes an effect's next step: a pure result, or a command to perform.
- *
- * This is the only function that knows how `Value` is laid out (a thunk
- * `() => T` for `Pure`, a `[command, payload, continuation]` tuple for `Do`).
- * Interpreters and proofs must go through `decode` (or `match`) instead of
- * inspecting the value, so the representation can change without touching
- * them.
- */
-export declare const decode: <O extends Operation, T>({ value }: Effect<O, T>) => Decoded<O, T>;
-/**
- * An operation map whose entries take a command's payload and return some
- * output `R`. Generalizes `ToAsyncOperationMap` (`R = Promise<…>`) and the
- * curried `MemOperationMap` (`R = (state) => [state, …]`).
- */
-export type OperationMap<O extends Operation, R> = {
-    readonly [K in O[0]]: (...payload: Pr<O, K>[0]) => R;
-};
-export type MatchResult<O extends Operation, T, R> = readonly ['done', T] | readonly ['cont', R, Do<O, T>[2]];
-/**
- * Decodes an effect's next step and dispatches its command to `map`,
- * returning either the final result or the operation's output `R` paired
- * with the continuation. The one world-specific step — `await` for async
- * runners, state threading for sync ones — is left to the caller, so every
- * interpreter loop is this skeleton plus a single eliminator line.
- */
-export declare const match: <O extends Operation, R>(map: OperationMap<O, R>) => <O1 extends O, T>(effect: Effect<O1, T>) => MatchResult<O1, T, R>;
-export type ToAsyncOperationMap<O extends Operation> = {
-    readonly [K in O[0]]: (...payload: Pr<O, K>[0]) => Promise<Pr<O, K>[1]>;
-};
-export type F<O extends Operation> = Pr<O, O[0]>;
-export type Func<O extends Operation> = (..._: Param<O>) => Effect<O, Return<O>>;

package/fs/effects/module.f.js

@@ -1,80 +0,0 @@
-/**
- * Core effect type constructors and combinators.
- *
- * Effect helpers are **step adapters**: functions that return a continuation
- * `(t: T) => Effect<Q, R>` meant to be passed into `.step`, never wrappers
- * that take the effect itself as an argument. `Effect` has no pipeline
- * operator to lean on and must not be extended with new methods, so
- * `.step(adapterA).step(adapterB)` is how helpers compose — flat,
- * left-to-right, in evaluation order. See {@link okStep} for an example.
- *
- * @module
- */
-import { fold } from '../types/list/module.f.js';
-export const pure = (v) => ({
-    value: () => v,
-    step: f => f(v)
-});
-/**
- * A lazy pure effect. Like {@link pure}, but takes a thunk and evaluates it on
- * demand instead of holding an already-computed value. Use this to produce the
- * next item of a list without instantiating the rest — the thunk runs only when
- * the effect is decoded (or stepped into).
- */
-export const lazy = (t) => ({
-    value: t,
-    step: f => f(t())
-});
-export const doFull = (cmd, param, cont) => ({
-    value: [cmd, param, cont],
-    step: (f) => doFull(cmd, param, x => cont(x).step(f)),
-});
-export const do_ = (cmd) => (...param) => doFull(cmd, param, pure);
-/**
- * Sequentially threads a state value through an effect for each item in `items`.
- *
- * Given `f: item => state => Effect<O, state>`, `init: S`, and `items: [x₀, x₁, …]`,
- * builds `f(x₀)(init).step(f(x₁)).step(f(x₂)).…` and yields a single
- * `Effect<O, S>` that produces the final state.
- *
- * Sequential — each step depends on the previous state. Compare to `all`,
- * which fans out independent effects.
- */
-export const foldStep = (f) => (init) => (items) => fold(item => acc => acc.step(f(item)))(pure(init))(items);
-/**
- * Sequentially runs `f(item)` for each item in `items`, discarding intermediate
- * results. The `void` accumulator sibling of `foldStep`.
- */
-export const forEachStep = (f) => (items) => foldStep((item) => () => f(item))(undefined)(items);
-/**
- * A step adapter for the `error` short-circuit: `error` → pass it through
- * unchanged as `pure`, `ok` → continue with `f`. Collapses the hand-written
- * `r[0] === 'error' ? pure(r) : f(r[1])` check that recurs at every site
- * chaining `Effect<O, Result<T, E>>` steps.
- */
-export const okStep = (f) => (r) => r[0] === 'error' ? pure(r) : f(r[1]);
-/**
- * Decodes an effect's next step: a pure result, or a command to perform.
- *
- * This is the only function that knows how `Value` is laid out (a thunk
- * `() => T` for `Pure`, a `[command, payload, continuation]` tuple for `Do`).
- * Interpreters and proofs must go through `decode` (or `match`) instead of
- * inspecting the value, so the representation can change without touching
- * them.
- */
-export const decode = ({ value }) => typeof value === 'function'
-    ? { done: true, result: value() }
-    : { done: false, command: value[0], payload: value[1], continuation: value[2] };
-/**
- * Decodes an effect's next step and dispatches its command to `map`,
- * returning either the final result or the operation's output `R` paired
- * with the continuation. The one world-specific step — `await` for async
- * runners, state threading for sync ones — is left to the caller, so every
- * interpreter loop is this skeleton plus a single eliminator line.
- */
-export const match = (map) => (effect) => {
-    const d = decode(effect);
-    return d.done
-        ? ['done', d.result]
-        : ['cont', map[d.command](...d.payload), d.continuation];
-};

package/fs/effects/proof.f.d.ts

@@ -1,25 +0,0 @@
-export declare const proof: {
-    lazy: {
-        value: () => void;
-        deferred: () => void;
-        step: () => void;
-    };
-    foldStep: {
-        empty: () => void;
-        threadsState: () => void;
-        order: () => void;
-    };
-    forEachStep: {
-        empty: () => void;
-        runs: () => void;
-    };
-    okStep: {
-        ok: () => void;
-        error: () => void;
-    };
-    decode: () => void;
-    match: {
-        done: () => void;
-        cont: () => void;
-    };
-};

package/fs/effects/proof.f.js

@@ -1,115 +0,0 @@
-import { decode, do_, foldStep, forEachStep, lazy, match, okStep, pure } from './module.f.js';
-import { error, ok } from '../types/result/module.f.js';
-const assertPure = (e, expected) => {
-    const d = decode(e);
-    if (!d.done) {
-        throw e.value;
-    }
-    if (d.result !== expected) {
-        throw d.result;
-    }
-};
-const next = match({ add: (a, b) => a + b });
-export const proof = {
-    lazy: {
-        value: () => {
-            assertPure(lazy(() => 42), 42);
-        },
-        deferred: () => {
-            // The thunk runs only when the effect is decoded, not when `lazy` is called.
-            let evaluated = false;
-            const e = lazy(() => { evaluated = true; return 7; });
-            if (evaluated) {
-                throw 'lazy must not evaluate eagerly';
-            }
-            assertPure(e, 7);
-            if (!evaluated) {
-                throw 'decode must force the thunk';
-            }
-        },
-        step: () => {
-            const e = lazy(() => 5).step(v => pure(v * 2));
-            assertPure(e, 10);
-        },
-    },
-    foldStep: {
-        empty: () => {
-            const e = foldStep((x) => (s) => pure(s + x))(10)([]);
-            assertPure(e, 10);
-        },
-        threadsState: () => {
-            const e = foldStep((x) => (s) => pure(s + x))(0)([1, 2, 3, 4]);
-            assertPure(e, 10);
-        },
-        order: () => {
-            const e = foldStep((x) => (s) => pure(s + x))('')(['a', 'b', 'c']);
-            assertPure(e, 'abc');
-        },
-    },
-    forEachStep: {
-        empty: () => {
-            const e = forEachStep(() => pure(undefined))([]);
-            assertPure(e, undefined);
-        },
-        runs: () => {
-            const e = forEachStep(() => pure(undefined))([1, 2, 3]);
-            assertPure(e, undefined);
-        },
-    },
-    okStep: {
-        ok: () => {
-            const e = pure(ok(5)).step(okStep((v) => pure(ok(v * 2))));
-            const d = decode(e);
-            if (!d.done || d.result[0] !== 'ok' || d.result[1] !== 10) {
-                throw e.value;
-            }
-        },
-        error: () => {
-            const e = pure(error('oops')).step(okStep(v => pure(ok(v * 2))));
-            const d = decode(e);
-            if (!d.done || d.result[0] !== 'error' || d.result[1] !== 'oops') {
-                throw e.value;
-            }
-        },
-    },
-    decode: () => {
-        const d = decode(do_('add')(2, 3));
-        if (d.done) {
-            throw d;
-        }
-        if (d.command !== 'add') {
-            throw d.command;
-        }
-        if (d.payload[0] !== 2 || d.payload[1] !== 3) {
-            throw d.payload;
-        }
-        assertPure(d.continuation(5), 5);
-    },
-    match: {
-        done: () => {
-            const r = next(pure(7));
-            if (r[0] !== 'done') {
-                throw r;
-            }
-            if (r[1] !== 7) {
-                throw r[1];
-            }
-        },
-        cont: () => {
-            const r = next(do_('add')(2, 3));
-            if (r[0] !== 'cont') {
-                throw r;
-            }
-            if (r[1] !== 5) {
-                throw r[1];
-            }
-            const r2 = next(r[2](r[1]));
-            if (r2[0] !== 'done') {
-                throw r2;
-            }
-            if (r2[1] !== 5) {
-                throw r2[1];
-            }
-        },
-    },
-};

package/fs/media/revision/proof.f.js

@@ -1,119 +0,0 @@
-import { assert, assertEq } from '../../asserts/module.f.js';
-import { dialect, mediaType, isHash, validate, decodeText } from './module.f.js';
-// Valid cbase32 hashes (round-tripped in fs/basen/cbase32/proof.f.ts): single
-// cbase32 symbols, cheap to write inline here.
-const h1 = '8';
-const h2 = 'r';
-const revisionOf = (extra) => ({
-    dialect,
-    subject: h1,
-    parents: [],
-    ...extra,
-});
-export const proof = {
-    dialectAndMediaType: () => {
-        assertEq(dialect, 'vnd.fjs.revision');
-        assertEq(mediaType, 'application/vnd.fjs.revision+json');
-    },
-    isHash: {
-        validHash: () => assert(isHash(h1)),
-        httpsRejected: () => assert(!isHash('https://example.com/blob/abc')),
-        arbitraryStringRejected: () => assert(!isHash('not-a-hash!')),
-    },
-    validate: {
-        // Zero parents, no `snapshot`: `subject` is the fallback snapshot
-        // reference and must itself be a hash.
-        firstRevisionFallsBackToSubjectHash: () => {
-            const [t] = validate(revisionOf({}));
-            assertEq(t, 'ok');
-        },
-        // Zero parents, no `snapshot`, `subject` is not a hash: invalid.
-        firstRevisionRejectsNonHashSubject: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config' }));
-            assertEq(t, 'error');
-        },
-        // `snapshot` present: `subject` may be an arbitrary string.
-        explicitSnapshotAllowsArbitrarySubject: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', snapshot: h2 }));
-            assertEq(t, 'ok');
-        },
-        // Exactly one parent, no `snapshot`: the parent's snapshot is inherited,
-        // and `subject` may be an arbitrary string.
-        singleParentInheritsSnapshot: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', parents: [h2] }));
-            assertEq(t, 'ok');
-        },
-        // More than one parent with no `snapshot`: invalid — no single parent
-        // snapshot to inherit, and falling back to `subject` would silently
-        // lose the merge result.
-        multiParentWithoutSnapshotRejected: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', parents: [h1, h2] }));
-            assertEq(t, 'error');
-        },
-        // A merge revision with an explicit `snapshot` is valid.
-        multiParentWithSnapshotAccepted: () => {
-            const [t, v] = validate(revisionOf({ subject: 'my-config', parents: [h1, h2], snapshot: h2 }));
-            assertEq(t, 'ok');
-            assertEq(v.snapshot, h2);
-        },
-        // `https://` bridge URLs are rejected wherever a hash is required.
-        httpsRejectedInParents: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', parents: ['https://example.com/x'], snapshot: h2 }));
-            assertEq(t, 'error');
-        },
-        httpsRejectedInSnapshot: () => {
-            const [t] = validate(revisionOf({ subject: 'my-config', snapshot: 'https://example.com/x' }));
-            assertEq(t, 'error');
-        },
-        httpsRejectedAsFallbackSubject: () => {
-            const [t] = validate(revisionOf({ subject: 'https://example.com/x' }));
-            assertEq(t, 'error');
-        },
-        // `archived` follows the presence-only `option(true)` idiom.
-        archivedAccepted: () => {
-            const [t] = validate(revisionOf({ archived: true }));
-            assertEq(t, 'ok');
-        },
-        // Wrong dialect tag: structural validation rejects it outright.
-        wrongDialectRejected: () => {
-            const [t] = validate({ dialect: 'vnd.fjs.other', subject: h1, parents: [] });
-            assertEq(t, 'error');
-        },
-        // Missing required fields: rejected.
-        missingSubjectRejected: () => {
-            const [t] = validate({ dialect, parents: [] });
-            assertEq(t, 'error');
-        },
-        // rtti structs are open: extra fields don't break validation — the
-        // additive forward-compatibility path the versioning rule relies on.
-        extraFieldsAccepted: () => {
-            const [t] = validate(revisionOf({ future: 'field' }));
-            assertEq(t, 'ok');
-        },
-    },
-    decodeText: {
-        validJson: () => {
-            const [t, v] = decodeText(JSON.stringify(revisionOf({ generation: 0 })));
-            assertEq(t, 'ok');
-            assertEq(v.subject, h1);
-        },
-        // Key order carries no meaning: detection parses the JSON and
-        // validates the parsed value, so `dialect` need not be first.
-        keyOrderIndependent: () => {
-            const text = `{"parents":[],"subject":"${h1}","dialect":"${dialect}"}`;
-            const [t] = decodeText(text);
-            assertEq(t, 'ok');
-        },
-        malformedJsonRejected: () => {
-            const [t] = decodeText('{not json');
-            assertEq(t, 'error');
-        },
-        // Ordinary JSON that isn't a revision at all falls through as an error
-        // here — `fs/media`'s composed detector is what falls back to the
-        // ordinary detector; this module only reports validity.
-        ordinaryJsonRejected: () => {
-            const [t] = decodeText('{"hello":"world"}');
-            assertEq(t, 'error');
-        },
-    },
-};

package/fs/text/ascii/proof.f.d.ts

@@ -1,4 +0,0 @@
-export declare const proof: {
-    range: () => void;
-    oneThrowsOnEmpty: () => void;
-};