functionalscript 0.2.0 → 0.2.1

package/out/dev/test.mjs

@@ -0,0 +1,52 @@
+import { loadModuleMap, exit, env } from './module.mjs';
+import test from './test/module.f.mjs';
+/** @type {(f: (s: string) => void) => (s: string) => <T>(_: T) => T} */
+const anyLog = f => s => state => {
+    f(s);
+    return state;
+};
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+/** @type {<T>(f: () => T) => Result<T, unknown>} */
+const tryCatch = f => {
+    // `try catch` is not allowed in FunctionalScript.
+    try {
+        return ['ok', f()];
+    }
+    catch (e) {
+        return ['error', e];
+    }
+};
+/** @type {<R>(f: () => R) => <T>(state: T) => readonly[R, number, T]} Measure} */
+const measure = f => state => {
+    const b = performance.now();
+    const r = f();
+    const e = performance.now();
+    return [r, e - b, state];
+};
+// test runner.
+const main = async () => {
+    const moduleMap = await loadModuleMap();
+    const r = test({
+        moduleMap,
+        log: anyLog(console.log),
+        error: anyLog(console.error),
+        measure,
+        tryCatch,
+        env,
+        state: void 0,
+    });
+    exit(r[0]);
+};
+main();

package/out/djs/module.f.mjs

@@ -0,0 +1,75 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../types/list/module.f.mjs';
+const { flat, map } = list;
+import * as string from '../types/string/module.f.mjs';
+const { concat } = string;
+import * as O from '../types/object/module.f.mjs';
+import * as f from '../types/function/module.f.mjs';
+const { compose, fn } = f;
+const { entries } = Object;
+import * as bi from '../types/bigint/module.f.mjs';
+const { serialize: bigintSerialize } = bi;
+import * as j from '../json/serializer/module.f.mjs';
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
+/**
+ * @typedef {{
+ *  readonly [k in string]: Unknown
+ * }} Object
+ */
+/** @typedef {readonly Unknown[]} Array */
+/** @typedef {Object|boolean|string|number|null|Array|bigint} Unknown */
+const colon = [':'];
+/** @typedef {O.Entry<Unknown>} Entry*/
+/** @typedef {(list.List<Entry>)} Entries */
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+export const serialize = sort => {
+    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ]);
+    const mapPropertySerialize = map(propertySerialize);
+    /** @type {(object: Object) => list.List<string>} */
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result;
+    /** @type {(value: Unknown) => list.List<string>} */
+    const f = value => {
+        switch (typeof value) {
+            case 'boolean': {
+                return boolSerialize(value);
+            }
+            case 'number': {
+                return numberSerialize(value);
+            }
+            case 'string': {
+                return stringSerialize(value);
+            }
+            case 'bigint': {
+                return [bigintSerialize(value)];
+            }
+            default: {
+                if (value === null) {
+                    return nullSerialize;
+                }
+                if (value instanceof Array) {
+                    return arraySerialize(value);
+                }
+                return objectSerialize(value);
+            }
+        }
+    };
+    const arraySerialize = compose(map(f))(arrayWrap);
+    return f;
+};
+/**
+ * The standard `JSON.stringify` rules determined by
+ * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
+ *
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
+ */
+export const stringify = sort => compose(serialize(sort))(concat);

package/out/djs/parser/module.f.mjs

@@ -0,0 +1,432 @@
+// @ts-self-types="./module.f.d.mts"
+import * as result from '../../types/result/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+const { fold, first, drop, toArray, map: listMap, length } = list;
+import * as Operator from '../../types/function/operator/module.f.mjs';
+import * as tokenizerT from '../tokenizer/module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';
+const { setReplace, at } = map;
+import * as o from '../../types/object/module.f.mjs';
+const { fromMap } = o;
+/** @typedef {[readonly string[], readonly DjsConst[]] } DjsModule */
+/** @typedef {boolean|string|number|null|bigint|DjsModuleRef|DjsArray|DjsObject} DjsConst */
+/** @typedef {['aref' | 'cref', number]} DjsModuleRef */
+/** @typedef {['array', readonly DjsConst[]]} DjsArray */
+/**
+ * @typedef {{
+*  readonly [k in string]: DjsConst
+* }} DjsObject
+*/
+/** @typedef {['array', list.List<DjsConst>]} DjsStackArray */
+/** @typedef {['object', map.Map<DjsConst>, string]} DjsStackObject */
+/**
+ * @typedef {|
+* DjsStackArray |
+* DjsStackObject
+* } DjsStackElement
+*/
+/** @typedef {list.List<DjsStackElement>} DjsStack */
+/** @typedef {InitialState | NewLineRequiredState | ImportState | ConstState | ExportState | ParseValueState | ResultState | ErrorState} ParserState */
+/**
+ * @typedef {{
+*  readonly refs: map.Map<DjsModuleRef>
+*  readonly modules: list.List<string>
+*  readonly consts: list.List<DjsConst>
+* }} ModuleState
+*/
+/**
+ * @typedef {{
+*  readonly state: ''
+*  readonly module: ModuleState
+* }} InitialState
+*/
+/**
+ * @typedef {{
+*  readonly state: 'nl'
+*  readonly module: ModuleState
+* }} NewLineRequiredState
+*/
+/**
+ * @typedef {{
+*  readonly state: 'import' | 'import+name' | 'import+from'
+*  readonly module: ModuleState
+* }} ImportState
+*/
+/**
+ * @typedef {{
+*  readonly state: 'const' | 'const+name'
+*  readonly module: ModuleState
+* }} ConstState
+*/
+/**
+ * @typedef {{
+*  readonly state: 'export'
+*  readonly module: ModuleState
+* }} ExportState
+*/
+/**
+ * @typedef {{
+*  readonly state: 'constValue' | 'exportValue'
+*  readonly module: ModuleState
+*  readonly valueState: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
+*  readonly top: DjsStackElement | null
+*  readonly stack: DjsStack
+* }} ParseValueState
+*/
+/**
+ * @typedef {{
+*  readonly state: 'result'
+*  readonly module: ModuleState
+* }} ResultState
+*/
+/**
+ * @typedef {{
+*  readonly state: 'error'
+*  readonly message: string
+* }} ErrorState
+*/
+/** @type {(token: tokenizerT.DjsToken) => (state: InitialState) => ParserState}} */
+const parseInitialOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state;
+        case 'id': {
+            switch (token.value) {
+                case 'import': return { ...state, state: 'import' };
+                case 'const': return { ...state, state: 'const' };
+                case 'export': return { ...state, state: 'export' };
+            }
+        }
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: NewLineRequiredState) => ParserState}} */
+const parseNewLineRequiredOp = token => state => {
+    switch (token.kind) {
+        case 'ws': return state;
+        case 'nl': return { ...state, state: '' };
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ExportState) => ParserState}} */
+const parseExportOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state;
+        case 'id': {
+            if (token.value === 'default')
+                return { ...state, state: 'exportValue', valueState: '', top: null, stack: null };
+        }
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ConstState) => ParserState}} */
+const parseConstOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state;
+        case 'id': {
+            if (map.at(token.value)(state.module.refs) !== null)
+                return { state: 'error', message: 'duplicate id' };
+            /** @type {DjsModuleRef} */
+            let cref = ['cref', length(state.module.consts)];
+            let refs = map.setReplace(token.value)(cref)(state.module.refs);
+            return { ...state, state: 'const+name', module: { ...state.module, refs: refs } };
+        }
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ConstState) => ParserState}} */
+const parseConstNameOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state;
+        case '=': return { ...state, state: 'constValue', valueState: '', top: null, stack: null };
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
+const parseImportOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state;
+        case 'id': {
+            if (map.at(token.value)(state.module.refs) !== null)
+                return { state: 'error', message: 'duplicate id' };
+            /** @type {DjsModuleRef} */
+            let aref = ['aref', length(state.module.modules)];
+            let refs = map.setReplace(token.value)(aref)(state.module.refs);
+            return { ...state, state: 'import+name', module: { ...state.module, refs: refs } };
+        }
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
+const parseImportNameOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state;
+        case 'id': {
+            if (token.value === 'from')
+                return { ...state, state: 'import+from' };
+        }
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ImportState) => ParserState}} */
+const parseImportFromOp = token => state => {
+    switch (token.kind) {
+        case 'ws':
+        case 'nl': return state;
+        case 'string': {
+            const modules = list.concat(state.module.modules)([token.value]);
+            return { ...state, state: 'nl', module: { ...state.module, modules: modules } };
+        }
+        default: return { state: 'error', message: 'unexpected token' };
+    }
+};
+/** @type {(obj: DjsStackObject) => (key: string) => DjsStackObject} */
+const addKeyToObject = obj => key => (['object', obj[1], key]);
+/** @type {(obj: DjsStackObject) => (value: DjsConst) => DjsStackObject} */
+const addValueToObject = obj => value => (['object', setReplace(obj[2])(value)(obj[1]), '']);
+/** @type {(array: DjsStackArray) => (value: DjsConst) => DjsStackArray} */
+const addToArray = array => value => (['array', list.concat(array[1])([value])]);
+/** @type {(state: ParseValueState) => (key: string) => ParserState} */
+const pushKey = state => key => {
+    if (state.top?.[0] === 'object') {
+        return { ...state, valueState: '{k', top: addKeyToObject(state.top)(key), stack: state.stack };
+    }
+    return { state: 'error', message: 'error' };
+};
+/** @type {(state: ParseValueState) => (value: DjsConst) => ParserState} */
+const pushValue = state => value => {
+    if (state.top === null) {
+        let consts = list.concat(state.module.consts)([value]);
+        switch (state.state) {
+            case 'exportValue': return { ...state, state: 'result', module: { ...state.module, consts: consts } };
+            case 'constValue': return { ...state, state: 'nl', module: { ...state.module, consts: consts } };
+        }
+    }
+    if (state.top?.[0] === 'array') {
+        return { ...state, valueState: '[v', top: addToArray(state.top)(value), stack: state.stack };
+    }
+    return { ...state, valueState: '{v', top: addValueToObject(state.top)(value), stack: state.stack };
+};
+/** @type {(state: ParseValueState) => (name: string) => ParserState} */
+const pushRef = state => name => {
+    const ref = at(name)(state.module.refs);
+    if (ref === null)
+        return { state: 'error', message: 'const not found' };
+    return pushValue(state)(ref);
+};
+/** @type {(state: ParseValueState) => ParserState} */
+const startArray = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
+    return { ...state, valueState: '[', top: ['array', null], stack: newStack };
+};
+/** @type {(state: ParseValueState) => ParserState} */
+const endArray = state => {
+    const top = state.top;
+    /** @type {ParseValueState} */
+    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    if (top !== null && top[0] === 'array') {
+        /** @type {DjsArray} */
+        const array = ['array', toArray(top[1])];
+        return pushValue(newState)(array);
+    }
+    return pushValue(newState)(null);
+};
+/** @type {(state: ParseValueState) => ParserState} */
+const startObject = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
+    return { ...state, valueState: '{', top: ['object', null, ''], stack: newStack };
+};
+/** @type {(state: ParseValueState) => ParserState} */
+const endObject = state => {
+    const obj = state?.top !== null && state?.top[0] === 'object' ? fromMap(state.top[1]) : null;
+    /** @type {ParseValueState} */
+    const newState = { ...state, valueState: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    return pushValue(newState)(obj);
+};
+/** @type {(token: tokenizerT.DjsToken) => DjsConst} */
+const tokenToValue = token => {
+    switch (token.kind) {
+        case 'null': return null;
+        case 'false': return false;
+        case 'true': return true;
+        case 'number': return parseFloat(token.value);
+        case 'string': return token.value;
+        case 'bigint': return token.value;
+        default: return null;
+    }
+};
+/** @type {(token: tokenizerT.DjsToken) => boolean} */
+const isValueToken = token => {
+    switch (token.kind) {
+        case 'null':
+        case 'false':
+        case 'true':
+        case 'number':
+        case 'string':
+        case 'bigint': return true;
+        default: return false;
+    }
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseValueOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    if (token.kind === 'id') {
+        return pushRef(state)(token.value);
+    }
+    if (token.kind === '[') {
+        return startArray(state);
+    }
+    if (token.kind === '{') {
+        return startObject(state);
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseArrayStartOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    if (token.kind === 'id') {
+        return pushRef(state)(token.value);
+    }
+    if (token.kind === '[') {
+        return startArray(state);
+    }
+    if (token.kind === ']') {
+        return endArray(state);
+    }
+    if (token.kind === '{') {
+        return startObject(state);
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseArrayValueOp = token => state => {
+    if (token.kind === ']') {
+        return endArray(state);
+    }
+    if (token.kind === ',') {
+        return { ...state, valueState: '[,', top: state.top, stack: state.stack };
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseObjectStartOp = token => state => {
+    if (token.kind === 'string') {
+        return pushKey(state)(token.value);
+    }
+    if (token.kind === '}') {
+        return endObject(state);
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseObjectKeyOp = token => state => {
+    if (token.kind === ':') {
+        return { ...state, valueState: '{:', top: state.top, stack: state.stack };
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseObjectColonOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    if (token.kind === 'id') {
+        return pushRef(state)(token.value);
+    }
+    if (token.kind === '[') {
+        return startArray(state);
+    }
+    if (token.kind === '{') {
+        return startObject(state);
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseObjectNextOp = token => state => {
+    if (token.kind === '}') {
+        return endObject(state);
+    }
+    if (token.kind === ',') {
+        return { ...state, valueState: '{,', top: state.top, stack: state.stack };
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {(token: tokenizerT.DjsToken) => (state: ParseValueState) => ParserState}} */
+const parseObjectCommaOp = token => state => {
+    if (token.kind === 'string') {
+        return pushKey(state)(token.value);
+    }
+    if (token.kind === 'ws') {
+        return state;
+    }
+    return { state: 'error', message: 'unexpected token' };
+};
+/** @type {Operator.Fold<tokenizerT.DjsToken, ParserState>} */
+const foldOp = token => state => {
+    switch (state.state) {
+        case '': return parseInitialOp(token)(state);
+        case 'nl': return parseNewLineRequiredOp(token)(state);
+        case 'import': return parseImportOp(token)(state);
+        case 'import+name': return parseImportNameOp(token)(state);
+        case 'import+from': return parseImportFromOp(token)(state);
+        case 'const': return parseConstOp(token)(state);
+        case 'const+name': return parseConstNameOp(token)(state);
+        case 'export': return parseExportOp(token)(state);
+        case 'result': return { state: 'error', message: 'unexpected token' };
+        case 'error': return { state: 'error', message: state.message };
+        case 'constValue':
+        case 'exportValue':
+            {
+                switch (state.valueState) {
+                    case '': return parseValueOp(token)(state);
+                    case '[': return parseArrayStartOp(token)(state);
+                    case '[v': return parseArrayValueOp(token)(state);
+                    case '[,': return parseValueOp(token)(state);
+                    case '{': return parseObjectStartOp(token)(state);
+                    case '{k': return parseObjectKeyOp(token)(state);
+                    case '{:': return parseObjectColonOp(token)(state);
+                    case '{v': return parseObjectNextOp(token)(state);
+                    case '{,': return parseObjectCommaOp(token)(state);
+                }
+            }
+    }
+};
+/** @type {(tokenList: list.List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>} */
+export const parse = tokenList => {
+    const state = fold(foldOp)({ state: '', module: { refs: null, modules: null, consts: null } })(tokenList);
+    switch (state.state) {
+        case 'result': return result.ok([toArray(state.module.modules), toArray(state.module.consts)]);
+        case 'error': return result.error(state.message);
+        default: return result.error('unexpected end');
+    }
+};