functionalscript 0.43.0 → 0.44.0

package/fjs/fsc/bnf.f.mjs

@@ -0,0 +1,77 @@
+import { range, remove, set, option } from '../bnf/module.f.mjs'
+/** @import { Rule } from '../bnf/types.ts' */
+import { digit, json, unicode, ws0, ws1, wsNoNewLine0 } from './json.f.mjs'
+
+/** @type {Rule} */
+export const wsModule = () => [ws0, module]
+
+/** @type {Rule} */
+const module = () => ({
+    json: [json, ws0],
+    fjs,
+})
+
+/** @type {Rule} */
+const fjs = () => option({
+    const: ['const', ws1, id, ws0, '=', ws0, json, wsNoNewLine0, fjsTail],
+    export: ['export', ws1, 'default', ws1, json],
+})
+
+/** @type {Rule} */
+const fjsTail = option(['\n', ws0, fjs])
+
+// line comment
+
+/** @type {Rule} */
+const lineItem = remove(unicode, set('\n'))
+
+/** @type {Rule} */
+const line = () => option([lineItem, line])
+
+/** @type {Rule} */
+const lineComment = () => ['/', commentTail, '\n']
+
+/** @type {Rule} */
+const multiLineSkip = remove(unicode, set('/'))
+
+/** @type {Rule} */
+const multiLineItem = remove(unicode, set('*'))
+
+/** @type {Rule} */
+const multiLine = () => ({
+    '*': ['*', multiLineTail],
+    '_': [multiLineItem, multiLine]
+})
+
+/** @type {Rule} */
+const multiLineTail = {
+    '/': '/',
+    '_': [multiLineSkip, multiLine]
+}
+
+/** @type {Rule} */
+const commentTail = {
+    '/': ['/', lineComment],
+    '*': ['*', multiLine],
+}
+
+// id
+
+/** @type {Rule} */
+const id = () => [alpha, idTail0]
+
+/** @type {Rule} */
+const alpha = {
+    upper: range('AZ'),
+    lower: range('az'),
+    _: set('_$'),
+}
+
+/** @type {Rule} */
+const idTail0 = () => option([alphaDigit, idTail0])
+
+/** @type {Rule} */
+const alphaDigit = {
+    alpha,
+    digit,
+}

package/fjs/fsc/json.f.d.mts

@@ -0,0 +1,13 @@
+import type { Rule, TerminalRange } from '../bnf/types.ts';
+/** @type {Rule} */
+export declare const wsNoNewLine0: Rule;
+/** @type {Rule} */
+export declare const ws0: Rule;
+/** @type {Rule} */
+export declare const ws1: Rule;
+/** @type {Rule} */
+export declare const json: Rule;
+/** @type {TerminalRange} */
+export declare const unicode: TerminalRange;
+/** @type {Rule} */
+export declare const digit: Rule;

package/fjs/fsc/json.f.mjs

@@ -0,0 +1,124 @@
+import { join0Plus, rangeEncode, range, remove, repeat0Plus, set, option } from '../bnf/module.f.mjs'
+/** @import { Rule, TerminalRange } from '../bnf/types.ts' */
+
+// space
+
+/** @type {Rule} */
+const wsNoNewLineItem = set(' \t\r')
+
+/** @type {Rule} */
+export const wsNoNewLine0 = repeat0Plus(wsNoNewLineItem)
+
+/** @type {Rule} */
+const wsItem = {
+    wsNoNewLineItem,
+    n: '\n',
+}
+
+/** @type {Rule} */
+export const ws0 = () => option(ws1)
+
+/** @type {Rule} */
+export const ws1 = [wsItem, ws0]
+
+//
+
+/** @type {Rule} */
+export const json = () => ({
+    object,
+    array,
+    number,
+    string,
+    true: 'true',
+    false: 'false',
+    null: 'null',
+})
+
+//
+
+/** @type {Rule} */
+const separator = [',', ws0]
+
+// object
+
+/** @type {Rule} */
+const member = () => [string, ws0, ':', ws0, json, ws0]
+
+/** @type {Rule} */
+const object = ['{', ws0, join0Plus(member, separator), '}']
+
+// array
+
+/** @type {Rule} */
+const element = [json, ws0]
+
+/** @type {Rule} */
+const array = ['[', ws0, join0Plus(element, separator), ']']
+
+// string
+
+/** @type {Rule} */
+const character = () => ({
+    ...remove(unicode, set('"\\')),
+    '\\': ['\\', escape],
+})
+
+/** @type {Rule} */
+const string = ['"', repeat0Plus(character), '"']
+
+/** @type {TerminalRange} */
+export const unicode = rangeEncode(0x20, 0x10FFFF)
+
+/** @type {Rule} */
+const escape = () => ({
+    ...set('"\\/bfnrt'),
+    'u': ['u', hex, hex, hex, hex] // 117
+})
+
+/** @type {Rule} */
+const hex = () => ({
+    digit,
+    upper: range('AF'),
+    lower: range('af'),
+})
+
+// number
+
+/** @type {Rule} */
+const number = () => ({
+    uNumber,
+    minus: ['-', uNumber],
+})
+
+/** @type {Rule} */
+const uNumber = () => [uint, fraction0, exponent0]
+
+/** @type {Rule} */
+const uint = () => ({
+    '0': '0',
+    '19': [range('19'), digits0]
+})
+
+/** @type {Rule} */
+export const digit = range('09')
+
+/** @type {Rule} */
+const digits0 = repeat0Plus(digit)
+
+/** @type {Rule} */
+const digits1 = [digit, digits0]
+
+/** @type {Rule} */
+const fraction0 = option(['.', digits1])
+
+/** @type {Rule} */
+const exponent0 = () => option([e, sign, digits1])
+
+/** @type {Rule} */
+const e = set('eE')
+
+/** @type {Rule} */
+const sign = option({
+    '+': '+',
+    '-': '-',
+})

package/fjs/fsc/module.f.d.mts

@@ -0,0 +1,14 @@
+import type { RangeMapArray } from '../types/range_map/types.ts';
+export type _Result = readonly [readonly string[], _ToResult];
+export type _ToResult = (codePoint: number) => _Result;
+export type _CreateToResult<T> = (state: T) => _ToResult;
+export type _State<T> = RangeMapArray<_CreateToResult<T>>;
+export declare const terminal = -1;
+/** @type {_ToResult} */
+export declare const init: _ToResult;
+export declare const proof: {
+    throw: {
+        unionConflict: () => void;
+    };
+    defHandler: () => void;
+};

package/fjs/fsc/module.f.mjs

@@ -0,0 +1,138 @@
+/**
+ * FunctionalScript command utilities for compile workflows.
+ *
+ * @module
+ */
+import { strictEqual } from '../types/function/operator/module.f.mjs'
+import { merge as rangeMapMerge, fromRange, get } from '../types/range_map/module.f.mjs'
+/** @import { RangeMapArray, RangeMerge } from '../types/range_map/types.ts' */
+import { reduce as listReduce, toArray, map } from '../types/list/module.f.mjs'
+/** @import { List } from '../types/list/types.ts' */
+import { range as asciiRange } from '../text/ascii/module.f.mjs'
+import { flip, fn } from '../types/function/module.f.mjs'
+import { one } from '../types/range/module.f.mjs'
+/** @import { Range } from '../types/range/types.ts' */
+import { assertEq } from '../asserts/module.f.mjs'
+
+const fromCharCode = String.fromCharCode
+
+/** @typedef {readonly [readonly string[], _ToResult]} _Result */
+
+/** @typedef {(codePoint: number) => _Result} _ToResult */
+
+/** @template T @typedef {(state: T) => _ToResult} _CreateToResult */
+
+/** @template T @typedef {RangeMapArray<_CreateToResult<T>>} _State */
+
+/** @type {_ToResult} */
+const unexpectedSymbol = codePoint => [[`unexpected symbol ${codePoint}`], unexpectedSymbol]
+
+/** @type {<T>(state: T) => _ToResult} */
+const def = _state => unexpectedSymbol
+
+const union =
+    /**
+     * @template T
+     * @param {_CreateToResult<T>} a
+     * @returns {(b: _CreateToResult<T>) => _CreateToResult<T>}
+     */
+    a => b => {
+        if (a === def || a === b) { return b }
+        if (b === def) { return a }
+        throw [a, b]
+    }
+
+/** @type {readonly never[]} */
+const empty = []
+
+const reduce =
+    /**
+     * @template T
+     * @param {List<_State<T>>} a
+     * @returns {_State<T>}
+     */
+    a => {
+        /** @type {RangeMerge<_CreateToResult<T>>} */
+        const merge = rangeMapMerge({
+            union,
+            equal: strictEqual,
+            def,
+        })
+        return toArray(listReduce(merge)(empty)(a))
+    }
+
+const codePointRange = flip(fromRange(def))
+
+const range = fn(asciiRange).map(codePointRange).result
+
+const rangeSet =
+    /** @param {readonly string[]} l */
+    l =>
+    /**
+     * @template T
+     * @param {_CreateToResult<T>} f
+     * @returns {_State<T>}
+     */
+    f => {
+        /** @type {(a: Range) => (f: _CreateToResult<T>) => _State<T>} */
+        const codePointRange = flip(fromRange(def))
+
+        /** @type {(r: string) => _State<T>} */
+        const g = r => codePointRange(asciiRange(r))(f)
+
+        return reduce(map(g)(l))
+    }
+
+const create =
+    /**
+     * @template T
+     * @param {List<_State<T>>} a
+     * @returns {_CreateToResult<T>}
+     */
+    a => {
+        const i = reduce(a)
+        /** @type {(i: _State<T>) => (v: number) => (v: T) => _ToResult} */
+        const x = get(def)
+        return v => c => x(i)(c)(v)(c)
+    }
+
+export const terminal = -1
+
+/** @type {() => _ToResult} */
+const toInit = () => () => [[], init]
+
+/** @type {(c: string) => _State<undefined>} */
+const single = c =>
+    range(c)(() => () => [[c], unexpectedSymbol])
+
+const punctuation = /** @type {const} */("!\"%&'()*+,-./:;<=>?[]^`{|}~")
+
+/** @type {_ToResult} */
+export const init = create([
+    codePointRange(one(terminal))(toInit),
+    rangeSet(['\t', ' ', '\n', '\r'])(toInit),
+    rangeSet(['$', '_', 'AZ', 'az'])(() => c => [[fromCharCode(c)], unexpectedSymbol]),
+    range('09')(() => a => [[fromCharCode(a)], unexpectedSymbol]),
+    ...[...punctuation].map(single),
+])(undefined)
+
+export const proof = {
+    // union throws when two distinct non-def handlers are merged for the same range;
+    // this path is unreachable through the public API (init has no overlapping ranges),
+    // so we exercise it here where the private union function is in scope.
+    throw: {
+        unionConflict: () => {
+            /** @type {_CreateToResult<undefined>} */
+            const a = _s => unexpectedSymbol
+            /** @type {_CreateToResult<undefined>} */
+            const b = _s => unexpectedSymbol
+            a(undefined)
+            b(undefined)
+            union(a)(b)
+        }
+    },
+    // `def` is the range-map's default handler; the public API never calls it directly
+    // (`init` covers every code point), so exercise it here where it's in scope.
+    defHandler: () =>
+        assertEq(def(undefined), unexpectedSymbol)
+}

package/fjs/fsc/proof.f.mjs

@@ -0,0 +1,119 @@
+import { init, terminal } from './module.f.mjs'
+import { one } from '../text/ascii/module.f.mjs'
+import { stringify } from '../media/json/module.f.mjs'
+import { assertEq } from '../asserts/module.f.mjs'
+
+const s = stringify(i => i)
+
+/** @type {(v: string) => string} */
+const f = v => {
+    const n = one(v)
+    return s(init(n)[0])
+}
+
+// this doesn't change a name of the function
+/** @type {(f: () => undefined, name: string) => (() => undefined)} */
+const fn = (f, name) => ({[name]: f}[name])
+
+/** @type {(name: string) => () => undefined} */
+const withName = name =>
+    // translated into one command: define a `function [name]() { return undefined }`
+    /** @type {any} */ (Object.getOwnPropertyDescriptor({[name]: () => undefined}, name)).value
+
+export const proof = {
+    a: () => {
+        const x = f('1')
+        assertEq(x, '["1"]')
+    },
+    b: () => {
+        // exercises toInit: terminal returns empty output and loops back to init
+        const result = init(terminal)
+        assertEq(result[0].length, 0, result[0])
+    },
+    c: () => {
+        // exercises unexpectedSymbol: next state after a token returns an error message
+        const next = init(one('1'))[1]
+        const result = next(42)
+        assertEq(result[0][0], 'unexpected symbol 42')
+    },
+    fn: () => {
+        const o = {
+            ["hello world!"]: () => undefined
+        }
+        const f = o["hello world!"]
+        const { name } = f
+        assertEq(name, "hello world!")
+        //
+        const f1 = { ["boring"]: () => undefined }["boring"]
+        assertEq(f1.name, "boring")
+        //
+        const x = fn(() => undefined, "hello").name
+        assertEq(x, "")
+        //
+        const m = withName("boring2").name
+        assertEq(m, "boring2")
+        //
+        const a = function x() { return undefined }
+        assertEq(a.name, "x")
+    },
+    //
+    f1: () => {
+        const m1 = () => undefined
+        assertEq(m1.name, "m1")
+    },
+    //
+    f2: () => {
+        const m11 = (() => undefined)
+        assertEq(m11.name, "m11")
+    },
+    //
+    f3: () => {
+        /** @type {any} */
+        const m2 = true ? () => undefined : () => undefined
+        // for `bun` it is `m2`:
+        // assertEq(m2.name, "")
+        // see also https://github.com/oven-sh/bun/issues/20398
+    },
+    f4: () => {
+        /**
+         * @template T
+         * @param {T} i
+         * @returns {T}
+         */
+        const id = i => i
+        /** @type {any} */
+        const f = id(() => undefined)
+        // for `bun` it is `m2`:
+        assertEq(f.name, "")
+    },
+    chars: {
+        whitespace: () => {
+            for (const ch of ['\t', ' ', '\n', '\r']) {
+                const [tokens, next] = init(one(ch))
+                assertEq(tokens.length, 0)
+                assertEq(next, init)
+            }
+        },
+        punctuation: () => {
+            for (const ch of ['!', '"', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', ':', ';', '<', '=', '>', '?', '[', ']', '^', '`', '{', '|', '}', '~']) {
+                const [tokens] = init(one(ch))
+                assertEq(tokens.length, 1)
+                assertEq(tokens[0], ch)
+            }
+        },
+        identifier_start: () => {
+            for (const ch of ['$', '_', 'A', 'Z', 'a', 'z']) {
+                const [tokens] = init(one(ch))
+                assertEq(tokens.length, 1)
+                assertEq(tokens[0], ch)
+            }
+        },
+        digits: () => {
+            for (const ch of ['0', '5', '9']) {
+                const [tokens] = init(one(ch))
+                assertEq(tokens.length, 1)
+                assertEq(tokens[0], ch)
+            }
+        },
+    },
+}

package/fjs/fsm/module.f.d.mts

@@ -0,0 +1,27 @@
+/**
+ * Finite state machine helpers used by parser and tokenizer logic.
+ *
+ * @module
+ *
+ * @import { List } from '../types/list/types.ts'
+ * @import { StringMap } from '../types/object/types.ts'
+ * @import { ByteSet } from '../types/byte_set/types.ts'
+ * @import { SortedSet } from '../types/sorted_set/types.ts'
+ * @import { RangeMap, Properties, RangeMapArray, Entry } from '../types/range_map/types.ts'
+ * @import { Fold, Scan } from '../types/function/operator/types.ts'
+ */
+import type { List } from '../types/list/types.ts';
+import type { StringMap } from '../types/object/types.ts';
+import type { ByteSet } from '../types/byte_set/types.ts';
+import type { RangeMapArray } from '../types/range_map/types.ts';
+export type _Rule = readonly [string, ByteSet, string];
+export type Grammar = List<_Rule>;
+export type _Dfa = StringMap<RangeMapArray<string>>;
+/** @type {(s: string) => ByteSet} */
+export declare const toRange: (s: string) => ByteSet;
+/** @type {(s: string) => ByteSet} */
+export declare const toUnion: (s: string) => ByteSet;
+/** @type {(grammar: Grammar) => _Dfa} */
+export declare const dfa: (grammar: Grammar) => _Dfa;
+/** @type {(dfa: _Dfa) => (input: List<number>) => List<string>} */
+export declare const run: (dfa: _Dfa) => (input: List<number>) => List<string>;

package/fjs/fsm/module.f.mjs

@@ -0,0 +1,99 @@
+/**
+ * Finite state machine helpers used by parser and tokenizer logic.
+ *
+ * @module
+ *
+ * @import { List } from '../types/list/types.ts'
+ * @import { StringMap } from '../types/object/types.ts'
+ * @import { ByteSet } from '../types/byte_set/types.ts'
+ * @import { SortedSet } from '../types/sorted_set/types.ts'
+ * @import { RangeMap, Properties, RangeMapArray, Entry } from '../types/range_map/types.ts'
+ * @import { Fold, Scan } from '../types/function/operator/types.ts'
+ */
+
+import { equal, isEmpty, fold, toArray, scan, foldScan, empty as emptyList } from '../types/list/module.f.mjs'
+import { toRangeMap, union as byteSetUnion, one, empty, range } from '../types/byte_set/module.f.mjs'
+import { intersect, union as sortedSetUnion } from '../types/sorted_set/module.f.mjs'
+import { merge, get as rangeMapGet } from '../types/range_map/module.f.mjs'
+import { strictEqual } from '../types/function/operator/module.f.mjs'
+import { stringify } from '../media/json/module.f.mjs'
+import { identity } from '../types/function/module.f.mjs'
+import { stringToList } from '../text/utf16/module.f.mjs'
+import { cmp } from '../types/string/module.f.mjs'
+
+/** @typedef {readonly [string, ByteSet, string]} _Rule */
+
+/** @typedef {List<_Rule>} Grammar */
+
+/** @typedef {StringMap<RangeMapArray<string>>} _Dfa */
+
+const stringifyIdentity = stringify(identity)
+
+/** @type {(s: string) => ByteSet} */
+export const toRange = s => {
+    const [b, e] = toArray(stringToList(s))
+    return range([b, e])
+}
+
+/** @type {Fold<number, ByteSet>} */
+const toUnionOp = i => bs => byteSetUnion(bs)(one(i))
+
+/** @type {(s: string) => ByteSet} */
+export const toUnion = s => {
+    const codePoints = stringToList(s)
+    return fold(toUnionOp)(empty)(codePoints)
+}
+
+/** @type {Properties<SortedSet<string>>} */
+const mergeOp = { union: sortedSetUnion(cmp), equal: equal(strictEqual), def: [] }
+
+/** @type {(s: string) => (set: SortedSet<string>) => boolean} */
+const hasState = s => set => !isEmpty(intersect(cmp)([s])(set))
+
+/** @type {(set: SortedSet<string>) => Fold<_Rule, RangeMap<SortedSet<string>>>} */
+const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
+    if (hasState(ruleIn)(set)) { return merge(mergeOp)(rm)(toRangeMap(bs)(ruleOut)) }
+    return rm
+}
+
+/** @type {Scan<Entry<SortedSet<string>>, Entry<string>>} */
+const stringifyOp = ([sortedSet, max]) => [[stringifyIdentity(sortedSet), max], stringifyOp]
+
+const scanStringify = scan(stringifyOp)
+
+/** @type {Scan<Entry<SortedSet<string>>, SortedSet<string>>} */
+const fetchOp = ([item, _]) => [item, fetchOp]
+
+const scanFetch = scan(fetchOp)
+
+/** @type {(grammar: Grammar) => Fold<SortedSet<string>, _Dfa>} */
+const addEntry = grammar => set => dfa => {
+    const s = stringifyIdentity(set)
+    if (s in dfa) { return dfa }
+    const setMap = fold(foldOp(set))(emptyList)(grammar)
+    const stringMap = toArray(scanStringify(setMap))
+    const newDfa = { ...dfa, [s]: stringMap }
+    const newStates = scanFetch(setMap)
+    return fold(addEntry(grammar))(newDfa)(newStates)
+}
+
+/** @type {string[]} */
+const emptyState = []
+
+const emptyStateStringify = stringifyIdentity(emptyState)
+
+const initialState = ['']
+
+const initialStateStringify = stringifyIdentity(initialState)
+
+/** @type {(grammar: Grammar) => _Dfa} */
+export const dfa = grammar => addEntry(grammar)(initialState)({})
+
+const get = rangeMapGet(emptyStateStringify)
+
+/** @type {(dfa: _Dfa) => Fold<number, string>} */
+const runOp = dfa => input => s => get(dfa[s] ?? [])(input)
+
+/** @type {(dfa: _Dfa) => (input: List<number>) => List<string>} */
+export const run = dfa => input =>
+    foldScan(runOp(dfa))(initialStateStringify)(input)