functionalscript 0.6.8 → 0.6.10

package/README.md

@@ -8,7 +8,7 @@ FunctionalScript is a safe, purely functional programming language and a strict
 
 - [JSON](https://en.wikipedia.org/wiki/JSON) and [JSON5](https://json5.org/) as subsets of JavaScript.
   JSON is also a subset of FunctionalScript.
-- [asm.JS](https://en.wikipedia.org/wiki/Asm.js)/[WebAssembly](https://en.wikipedia.org/wiki/WebAssembly),
+- [asm.JS](https://en.wikipedia.org/wiki/Asm.js) (a precursor of [WebAssembly](https://en.wikipedia.org/wiki/WebAssembly)),
   as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
@@ -19,7 +19,7 @@ Learn more about
 - [Purely Functional Programming in JavaScript](https://blog.bitsrc.io/purely-functional-programming-in-javascript-91114b1b2dff?sk=5f7132e56902f38fcf4c6164bfa681ed),
 - [FunctionalScript and I/O](https://medium.com/@sergeyshandar/functionalscript-5cf817345376?sk=30b32189a81d1a2dad16c2244f32328d).
 
-This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributted under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
+This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributed under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
 
 ## Getting Started
 

package/bnf/data/module.f.d.ts

@@ -1,10 +1,12 @@
 import type { Rule as FRule } from '../module.f.ts';
 export type TerminalRange = number;
 export type Sequence = readonly string[];
+/** A variant of rule names. */
 export type Variant = {
     readonly [k in string]: string;
 };
 export type Rule = Variant | Sequence | TerminalRange;
+/** The full grammar */
 export type RuleSet = Readonly<Record<string, Rule>>;
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
 /**

package/bnf/data/test.f.d.ts

@@ -1,4 +1,5 @@
 declare const _default: {
     toData: () => void;
+    example: () => void;
 };
 export default _default;

package/bnf/data/test.f.js

@@ -4,5 +4,16 @@ export default {
     toData: () => {
         const c = toData(classic());
         const d = toData(deterministic());
+    },
+    example: () => {
+        const grammar = {
+            space: 0x000020_000020,
+            digit: 0x000030_000039,
+            sequence: ['space', 'digit'],
+            spaceOrDigit: {
+                'whiteSpace': 'space',
+                'digit': 'digit',
+            }
+        };
     }
 };

package/bnf/module.f.d.ts

@@ -1,6 +1,14 @@
 import { type Array2 } from '../types/array/module.f.ts';
+/**
+ * A range of symbols (48 bits)
+ * For example: 0xBBBBBB_EEEEEE
+ * - 0xBBBBBB is the first symbol
+ * - 0xEEEEEE is the last symbol
+ */
 export type TerminalRange = number;
+/** A sequence of rules. */
 export type Sequence = readonly Rule[];
+/** A variant */
 export type Variant = {
     readonly [k in string]: Rule;
 };

package/bnf/module.f.js

@@ -1,7 +1,7 @@
 import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
 import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
-//
+// Internals:
 const { fromEntries, values } = Object;
 const { fromCodePoint } = String;
 /**

package/bnf/testlib.f.js

@@ -1,5 +1,6 @@
 import { join0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
 export const classic = () => {
+    // https://www.json.org/json-en.html
     const json = () => [element];
     const value = () => ({
         object,

package/dev/module.f.d.ts

@@ -7,6 +7,6 @@ export type ModuleMap = {
     readonly [k in string]: Module;
 };
 export declare const env: (io: Io) => (v: string) => string | undefined;
-export declare const allFiles: ({ fs: { promises: { readdir } } }: Io) => Promise<readonly string[]>;
+export declare const allFiles: (io: Io) => (s: string) => Promise<readonly string[]>;
 export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
 export declare const index: (io: Io) => Promise<number>;

package/dev/module.f.js

@@ -7,7 +7,8 @@ export const env = ({ process: { env } }) => a => {
         typeof r.get === 'function' ? r.get() :
             r.value;
 };
-export const allFiles = ({ fs: { promises: { readdir } } }) => {
+export const allFiles = (io) => (s) => {
+    const { fs: { promises: { readdir } }, process: { cwd } } = io;
     const load = async (p) => {
         let result = [];
         for (const i of await readdir(p, { withFileTypes: true })) {
@@ -29,12 +30,14 @@ export const allFiles = ({ fs: { promises: { readdir } } }) => {
         }
         return result;
     };
-    return load('.');
+    return load(s);
 };
 export const loadModuleMap = async (io) => {
     const { fs: { existsSync }, asyncImport } = io;
     let map = [];
-    for (const f of await allFiles(io)) {
+    const initCwd = env(io)('INIT_CWD');
+    const s = initCwd === undefined ? '.' : `${initCwd.replaceAll('\\', '/')}`;
+    for (const f of await allFiles(io)(s)) {
         if (f.endsWith('.f.js') ||
             (f.endsWith('.f.ts') && !existsSync(f.substring(0, f.length - 3) + '.js'))) {
             const source = await asyncImport(f);
@@ -47,7 +50,7 @@ export const index = async (io) => {
     updateVersion(io);
     const jj = './deno.json';
     const jsr_json = JSON.parse(await io.fs.promises.readFile(jj, 'utf8'));
-    const list = (await allFiles(io)).filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
+    const list = (await allFiles(io)('.')).filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
     //console.log(list)
     const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
     // console.log(exportsA)

package/djs/module.f.js

@@ -22,7 +22,8 @@ export const compile = ({ console: { error }, fs, process: { argv } }) => {
             break;
         }
         case 'error': {
-            error(`Parse error: ${result[1]}`);
+            const metadata = result[1].metadata;
+            error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`);
             break;
         }
     }

package/djs/parser/module.f.d.ts

@@ -1,12 +1,17 @@
 import * as result from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
-import type { DjsToken } from '../tokenizer/module.f.ts';
+import type { DjsTokenWithMetadata } from '../tokenizer/module.f.ts';
 import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import type { Fs } from '../../io/module.f.ts';
 import type { AstModule } from '../ast/module.f.ts';
+import type { TokenMetadata } from '../../js/tokenizer/module.f.ts';
 export type ParseContext = {
     readonly fs: Fs;
     readonly complete: OrderedMap<result.Result<AstModule, string>>;
     readonly stack: List<string>;
 };
-export declare const parseFromTokens: (tokenList: List<DjsToken>) => result.Result<AstModule, string>;
+export type ParseError = {
+    readonly message: string;
+    readonly metadata: TokenMetadata | null;
+};
+export declare const parseFromTokens: (tokenList: List<DjsTokenWithMetadata>) => result.Result<AstModule, ParseError>;

package/djs/parser/module.f.js

@@ -2,7 +2,7 @@ import * as result from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
 import { setReplace, at } from "../../types/ordered_map/module.f.js";
 import { fromMap } from "../../types/object/module.f.js";
-const parseInitialOp = token => state => {
+const parseInitialOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
@@ -16,40 +16,43 @@ const parseInitialOp = token => state => {
             }
         }
     }
-    return foldOp(token)({ ...state, state: 'exportValue', valueState: '', top: null, stack: null });
+    return foldOp({ token, metadata })({ ...state, state: 'exportValue', valueState: '', top: null, stack: null });
 };
-const parseNewLineRequiredOp = token => state => {
+const parseNewLineRequiredOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case '//':
         case '/*': return state;
         case 'nl': return { ...state, state: '' };
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseExportOp = token => state => {
+const parseExportOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
         case 'id': {
             if (token.value === 'default')
                 return { ...state, state: 'exportValue', valueState: '', top: null, stack: null };
         }
     }
-    return { state: 'error', message: 'unexpected token' };
+    return { state: 'error', error: { message: 'unexpected token', metadata } };
 };
-const parseResultOp = token => state => {
+const parseResultOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
         case '//':
-        case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case '/*':
+        case 'eof': return state;
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseConstOp = token => state => {
+const parseConstOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
@@ -57,25 +60,27 @@ const parseConstOp = token => state => {
         case '/*': return state;
         case 'id': {
             if (at(token.value)(state.module.refs) !== null)
-                return { state: 'error', message: 'duplicate id' };
+                return { state: 'error', error: { message: 'duplicate id', metadata } };
             const cref = ['cref', length(state.module.consts)];
             const refs = setReplace(token.value)(cref)(state.module.refs);
             return { ...state, state: 'const+name', module: { ...state.module, refs: refs } };
         }
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseConstNameOp = token => state => {
+const parseConstNameOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
         case '=': return { ...state, state: 'constValue', valueState: '', top: null, stack: null };
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseImportOp = token => state => {
+const parseImportOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
@@ -83,29 +88,31 @@ const parseImportOp = token => state => {
         case '/*': return state;
         case 'id': {
             if (at(token.value)(state.module.refs) !== null) {
-                return { state: 'error', message: 'duplicate id' };
+                return { state: 'error', error: { message: 'duplicate id', metadata } };
             }
             const aref = ['aref', length(state.module.modules)];
             const refs = setReplace(token.value)(aref)(state.module.refs);
             return { ...state, state: 'import+name', module: { ...state.module, refs: refs } };
         }
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseImportNameOp = token => state => {
+const parseImportNameOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
         case 'id': {
             if (token.value === 'from')
                 return { ...state, state: 'import+from' };
         }
     }
-    return { state: 'error', message: 'unexpected token' };
+    return { state: 'error', error: { message: 'unexpected token', metadata } };
 };
-const parseImportFromOp = token => state => {
+const parseImportFromOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
         case 'nl':
@@ -115,17 +122,18 @@ const parseImportFromOp = token => state => {
             const modules = concat(state.module.modules)([token.value]);
             return { ...state, state: 'nl', module: { ...state.module, modules: modules } };
         }
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
 const addKeyToObject = obj => key => (['object', obj[1], key]);
 const addValueToObject = obj => value => (['object', setReplace(obj[2])(value)(obj[1]), '']);
 const addToArray = array => value => (['array', concat(array[1])([value])]);
-const pushKey = state => key => {
+const pushKey = state => key => metadata => {
     if (state.top?.[0] === 'object') {
         return { ...state, valueState: '{k', top: addKeyToObject(state.top)(key), stack: state.stack };
     }
-    return { state: 'error', message: 'error' };
+    return { state: 'error', error: { message: 'error', metadata } };
 };
 const pushValue = state => value => {
     if (state.top === null) {
@@ -140,10 +148,10 @@ const pushValue = state => value => {
     }
     return { ...state, valueState: '{v', top: addValueToObject(state.top)(value), stack: state.stack };
 };
-const pushRef = state => name => {
+const pushRef = state => name => metadata => {
     const ref = at(name)(state.module.refs);
     if (ref === null)
-        return { state: 'error', message: 'const not found' };
+        return { state: 'error', error: { message: 'const not found', metadata } };
     return pushValue(state)(ref);
 };
 const startArray = state => {
@@ -192,27 +200,34 @@ const isValueToken = token => {
         default: return false;
     }
 };
-const parseValueOp = token => state => {
-    if (isValueToken(token)) {
-        return pushValue(state)(tokenToValue(token));
-    }
+const parseValueOp = ({ token, metadata }) => state => {
     switch (token.kind) {
-        case 'id': return pushRef(state)(token.value);
+        case ']':
+            if (state.valueState === '[,') {
+                return endArray(state);
+            }
+            return { state: 'error', error: { message: 'unexpected token', metadata } };
+        case 'id': return pushRef(state)(token.value)(metadata);
         case '[': return startArray(state);
         case '{': return startObject(state);
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default:
+            if (isValueToken(token)) {
+                return pushValue(state)(tokenToValue(token));
+            }
+            return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseArrayStartOp = token => state => {
+const parseArrayStartOp = ({ token, metadata }) => state => {
     if (isValueToken(token)) {
         return pushValue(state)(tokenToValue(token));
     }
     switch (token.kind) {
-        case 'id': return pushRef(state)(token.value);
+        case 'id': return pushRef(state)(token.value)(metadata);
         case '[': return startArray(state);
         case ']': return endArray(state);
         case '{': return startObject(state);
@@ -220,10 +235,11 @@ const parseArrayStartOp = token => state => {
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseArrayValueOp = token => state => {
+const parseArrayValueOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case ']': return endArray(state);
         case ',': return { ...state, valueState: '[,', top: state.top, stack: state.stack };
@@ -231,46 +247,53 @@ const parseArrayValueOp = token => state => {
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseObjectStartOp = token => state => {
+// allow identifier property names (#2410)
+const parseObjectStartOp = ({ token, metadata }) => state => {
     switch (token.kind) {
-        case 'string': return pushKey(state)(token.value);
+        case 'string':
+        case 'id':
+            return pushKey(state)(String(token.value))(metadata);
         case '}': return endObject(state);
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseObjectKeyOp = token => state => {
+const parseObjectKeyOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case ':': return { ...state, valueState: '{:', top: state.top, stack: state.stack };
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseObjectColonOp = token => state => {
+const parseObjectColonOp = ({ token, metadata }) => state => {
     if (isValueToken(token)) {
         return pushValue(state)(tokenToValue(token));
     }
     switch (token.kind) {
-        case 'id': return pushRef(state)(token.value);
+        case 'id': return pushRef(state)(token.value)(metadata);
         case '[': return startArray(state);
         case '{': return startObject(state);
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseObjectNextOp = token => state => {
+const parseObjectNextOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case '}': return endObject(state);
         case ',': return { ...state, valueState: '{,', top: state.top, stack: state.stack };
@@ -278,17 +301,22 @@ const parseObjectNextOp = token => state => {
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
-const parseObjectCommaOp = token => state => {
+const parseObjectCommaOp = ({ token, metadata }) => state => {
     switch (token.kind) {
-        case 'string': return pushKey(state)(token.value);
+        case '}': return endObject(state);
+        case 'string':
+        case 'id':
+            return pushKey(state)(String(token.value))(metadata);
         case 'ws':
         case 'nl':
         case '//':
         case '/*': return state;
-        default: return { state: 'error', message: 'unexpected token' };
+        case 'eof': return { state: 'error', error: { message: 'unexpected end', metadata } };
+        default: return { state: 'error', error: { message: 'unexpected token', metadata } };
     }
 };
 const foldOp = token => state => {
@@ -302,7 +330,7 @@ const foldOp = token => state => {
         case 'const+name': return parseConstNameOp(token)(state);
         case 'export': return parseExportOp(token)(state);
         case 'result': return parseResultOp(token)(state);
-        case 'error': return { state: 'error', message: state.message };
+        case 'error': return { state: 'error', error: state.error };
         case 'constValue':
         case 'exportValue':
             {
@@ -324,7 +352,7 @@ export const parseFromTokens = (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');
+        case 'error': return result.error(state.error);
+        default: return result.error({ message: 'unexpected end', metadata: null });
     }
 };

package/djs/parser/test.f.d.ts

@@ -1,6 +1,7 @@
 declare const _default: {
     valid: (() => void)[];
     invalid: (() => void)[];
+    errorMetadata: (() => void)[];
     validWhiteSpaces: (() => void)[];
     validJson: (() => void)[];
     invalidModule: (() => void)[];