functionalscript 0.6.9 → 0.6.11

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';
+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/module.f.js

@@ -1,5 +1,6 @@
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { toArray } from "../../types/list/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+import { oneEncode, } from "../module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
     for (const [k, v] of entries(map)) {
@@ -40,10 +41,11 @@ const variant = (fr) => map => {
     }
     return [map, set, rule];
 };
+const mapOneEncode = map(oneEncode);
 const data = (dr) => {
     switch (typeof dr) {
         case 'string': {
-            return sequence(toArray(stringToCodePointList(dr)));
+            return sequence(toArray(mapOneEncode(stringToCodePointList(dr))));
         }
         case 'number':
             return m => [m, {}, dr];

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

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

package/bnf/data/test.f.js

@@ -1,8 +1,76 @@
+import { stringify } from "../../json/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { range } from "../module.f.js";
 import { classic, deterministic } from "../testlib.f.js";
 import { toData } from "./module.f.js";
 export default {
-    toData: () => {
-        const c = toData(classic());
-        const d = toData(deterministic());
+    toData: [
+        () => {
+            const c = toData(classic());
+            const d = toData(deterministic());
+        },
+        () => {
+            const stringRule = 'true';
+            const result = stringify(sort)(toData(stringRule));
+            if (result != '[{"":["0","1","2","3"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917},""]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const result = stringify(sort)(toData(terminalRangeRule));
+            if (result != '[{"":1090519110},""]') {
+                throw result;
+            } //1090519110 = 65 * 2^24 + 70
+        },
+        () => {
+            const sequenceRangeRule = [range('AF'), range('af')];
+            const result = stringify(sort)(toData(sequenceRangeRule));
+            if (result != '[{"":["0","1"],"0":1090519110,"1":1627390054},""]') {
+                throw result;
+            }
+        },
+        () => {
+            const lazyRule = () => 'true';
+            const result = stringify(sort)(toData(lazyRule));
+            if (result != '[{"":1946157172,"0":1912602738,"1":1962934389,"2":1694498917,"lazyRule":["","0","1","2"]},"lazyRule"]') {
+                throw result;
+            }
+        },
+        () => {
+            const varintRule = { true: 'true', false: 'false' };
+            const result = stringify(sort)(toData(varintRule));
+            const expected = '[{"":{"false":"5","true":"0"},"0":["1","2","3","4"],"1":1946157172,"2":1912602738,"3":1962934389,"4":1694498917,"5":["6","7","8","9","4"],"6":1711276134,"7":1627390049,"8":1811939436,"9":1929379955},""]';
+            if (result != expected) {
+                throw [result, expected];
+            }
+        },
+        () => {
+            const lazyRule = () => 'true';
+            const lazyRule0 = () => 'false';
+            const result = stringify(sort)(toData([lazyRule, lazyRule0]));
+            const expected = '[{"":["lazyRule","lazyRule0"],"0":1946157172,"1":1912602738,"2":1962934389,"3":1694498917,"4":1711276134,"5":1627390049,"6":1811939436,"7":1929379955,"lazyRule":["0","1","2","3"],"lazyRule0":["4","5","6","7","3"]},""]';
+            if (result != expected) {
+                throw [result, expected];
+            }
+        },
+    ],
+    variantTest: () => {
+        const varintRule = { a: 'a', b: 'b' };
+        const result = stringify(sort)(toData(varintRule));
+        if (result != '[{"":{"a":"0","b":"2"},"0":["1"],"1":1627390049,"2":["3"],"3":1644167266},""]') {
+            throw result;
+        }
+    },
+    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/crypto/hmac/module.f.js

@@ -48,13 +48,18 @@ export const hmac = (sha2) => {
     const op = p(oPad);
     const c = computeSync(sha2);
     const vbl = vec(blockLength);
+    // a and b should have the same size
     const xor = (a) => (b) => vbl(a ^ b);
-    return k => m => {
+    return k => {
         const k1 = length(k) > blockLength ? c([k]) : k;
         const k2 = concat(k1)(vec(blockLength - length(k1))(0n));
         const xk2 = xor(k2);
-        const f = (p, msg) => c([xk2(p), msg]);
-        const m1 = f(ip, m);
-        return f(op, m1);
+        const f = (p) => {
+            const x = xk2(p);
+            return (msg) => c([x, msg]);
+        };
+        const fip = f(ip);
+        const fop = f(op);
+        return m => fop(fip(m));
     };
 };

package/crypto/sha2/module.f.d.ts

@@ -37,7 +37,7 @@ export type Base = {
  * const s = msbUtf8("The quick brown fox jumps over the lazy dog.")
  * let state = sha224.init
  * state = sha224.append(state)(s)
- * const h = sha224.end(state) // 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn
+ * const h = sha224.end(state) // 0x1_619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn
  * ```
  */
 export type Sha2 = {

package/crypto/sign/module.f.d.ts

@@ -0,0 +1,5 @@
+import { type Vec } from '../../types/bit_vec/module.f.ts';
+import { type Init } from '../secp/module.f.ts';
+import type { Sha2 } from '../sha2/module.f.ts';
+export declare const newPrivateKey: (i: Init) => (random: Vec) => Vec;
+export declare const sign: (sha2: Sha2) => (curveInit: Init) => (privateKey: Vec) => (messageHash: Vec) => readonly [bigint, bigint];

package/crypto/sign/module.f.js

@@ -0,0 +1,53 @@
+import { listToVec, msb, uint, vec, vec8, length } from "../../types/bit_vec/module.f.js";
+import { hmac } from "../hmac/module.f.js";
+import { curve } from "../secp/module.f.js";
+const concat = listToVec(msb);
+const v00 = vec8(0x00n);
+const v01 = vec8(0x01n);
+/**
+ * The size of the result equals the size of the hash.
+ *
+ * @param sha2 SHA2 hash function
+ * @returns A function that accepts a private key, a message hash and returns `k`.
+ */
+const createK = (sha2) => {
+    const h = hmac(sha2);
+    let vs = vec(sha2.hashLength);
+    let k0 = vs(0x00n);
+    let v0 = vs(0x01n);
+    return (privateKey) => (messageHash) => {
+        const pm = concat([privateKey, messageHash]);
+        let k = k0;
+        let v = v0;
+        k = h(k)(concat([v, v00, pm]));
+        v = h(k)(v);
+        k = h(k)(concat([v, v01, pm]));
+        v = h(k)(v);
+        return uint(h(k)(v));
+    };
+};
+export const newPrivateKey = (i) => (random) => {
+    const { nf } = curve(i);
+    if (length(nf.max) < length(random)) {
+        throw "need more random bits";
+    }
+    return uint(random) % nf.p;
+};
+export const sign = (sha2) => (curveInit) => (privateKey) => (messageHash) => {
+    const { mul, pf } = curve(curveInit);
+    // const curveVec = vec(length(pf.max))
+    //`k` is a unique for each `z` and secret.
+    const k = createK(sha2)(privateKey)(messageHash) % pf.p;
+    // `R = G * k`.
+    const rp = mul(curveInit.g)(k);
+    // `r = R.x`
+    const r = rp === null ? 0n : rp[0];
+    // `s = ((z + r * d) / k)`.
+    const d = uint(privateKey);
+    const z = uint(messageHash);
+    const rd = pf.mul(r)(d);
+    const zrd = pf.add(z)(rd);
+    const kn1 = pf.reciprocal(k);
+    const s = pf.mul(zrd)(kn1);
+    return [r, s];
+};

package/crypto/sign/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/crypto/sign/test.f.js

@@ -0,0 +1 @@
+export default {};

package/deno/module.d.ts

@@ -0,0 +1,8 @@
+type DenoTestStep = {
+    readonly step: (name: string, f: () => void | Promise<void>) => Promise<void>;
+};
+type DenoFunc = (t: DenoTestStep) => void | Promise<void>;
+type DenoArg = readonly [string, DenoFunc];
+export type DenoTest = (...arg: DenoArg) => void;
+declare const _default: () => Promise<void>;
+export default _default;

package/deno/module.js

@@ -0,0 +1,53 @@
+import { io } from "../io/module.js";
+import { loadModuleMap } from "../dev/module.f.js";
+import { isTest } from "../dev/test/module.f.js";
+const denoTest = (x) => async (t) => {
+    let subTests = [x];
+    while (true) {
+        const [first, ...rest] = subTests;
+        if (first === undefined) {
+            break;
+        }
+        subTests = rest;
+        //
+        const [name, value] = first;
+        if (value === null) {
+            continue;
+        }
+        switch (typeof value) {
+            case "function": {
+                if (value.length === 0) {
+                    const g = value.name === 'throw'
+                        ? () => {
+                            try {
+                                value();
+                                throw new Error(`Expected ${name} to throw, but it did not.`);
+                            }
+                            catch { }
+                        }
+                        : () => {
+                            const r = value();
+                            subTests = [...subTests, [`${name}()`, r]];
+                        };
+                    await t.step(name, g);
+                }
+                break;
+            }
+            case "object": {
+                for (const [j, y] of Object.entries(value)) {
+                    const pr = `${name}/${j}`;
+                    subTests = [...subTests, [pr, y]];
+                }
+                break;
+            }
+        }
+    }
+};
+export default async () => {
+    const x = await loadModuleMap(io);
+    for (const [i, v] of Object.entries(x)) {
+        if (isTest(i)) {
+            Deno.test(i, denoTest(['', v.default]));
+        }
+    }
+};

package/deno/test.d.ts

@@ -0,0 +1 @@
+export {};

package/deno/test.js

@@ -0,0 +1,2 @@
+import run from "./module.js";
+await run();

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/dev/test/module.f.d.ts

@@ -1,7 +1,8 @@
+import { type CsiConsole } from '../../text/sgr/module.f.ts';
 import type * as Result from '../../types/result/module.f.ts';
 import type { Io, Performance } from '../../io/module.f.ts';
 import { type ModuleMap } from '../module.f.ts';
-type Log<T> = (v: string) => (state: T) => T;
+type Log<T> = CsiConsole;
 type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
 type Input<T> = {
     readonly moduleMap: ModuleMap;
@@ -12,6 +13,7 @@ type Input<T> = {
     readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
     readonly env: (n: string) => string | undefined;
 };
+export declare const isTest: (s: string) => boolean;
 export declare const test: <T>(input: Input<T>) => readonly [number, T];
 export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
 export declare const measure: (p: Performance) => <R>(f: () => R) => <T>(state: T) => readonly [R, number, T];

package/dev/test/module.f.js

@@ -1,7 +1,7 @@
 import { entries, fold } from "../../types/list/module.f.js";
-import { reset, fgGreen, fgRed, bold } from "../../text/sgr/module.f.js";
+import { reset, fgGreen, fgRed, bold, stdio, stderr } from "../../text/sgr/module.f.js";
 import { env, loadModuleMap } from "../module.f.js";
-const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
+export const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
 const timeFormat = (a) => {
@@ -30,16 +30,16 @@ export const test = (input) => {
                             if (isGitHub) {
                                 // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
                                 // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                                state = error(`::error file=${k},line=1,title=[3]['a']()::${r}`)(state);
+                                error(`::error file=${k},line=1,title=[3]['a']()::${r}`);
                             }
                             else {
-                                state = error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`)(state);
-                                state = error(`${fgRed}${r}${reset}`)(state);
+                                error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);
+                                error(`${fgRed}${r}${reset}`);
                             }
                         }
                         else {
                             ts = addPass(delta)(ts);
-                            state = log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`)(state);
+                            log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
                         }
                         [ts, state] = next(r)([ts, state]);
                     }
@@ -48,7 +48,7 @@ export const test = (input) => {
                 case 'object': {
                     if (v !== null) {
                         const f = ([k, v]) => ([time, state]) => {
-                            state = log(`${i}${k}:`)(state);
+                            log(`${i}${k}:`);
                             [time, state] = next(v)([time, state]);
                             return [time, state];
                         };
@@ -61,7 +61,7 @@ export const test = (input) => {
         };
         return ([ts, state]) => {
             if (isTest(k)) {
-                state = log(`testing ${k}`)(state);
+                log(`testing ${k}`);
                 [ts, state] = test('| ')(v.default)([ts, state]);
             }
             return [ts, state];
@@ -70,8 +70,8 @@ export const test = (input) => {
     let ts = { time: 0, pass: 0, fail: 0 };
     [ts, state] = fold(f)([ts, state])(Object.entries(moduleMap));
     const fgFail = ts.fail === 0 ? fgGreen : fgRed;
-    state = log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`)(state);
-    state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
+    log(`${bold}Number of tests: pass: ${fgGreen}${ts.pass}${reset}${bold}, fail: ${fgFail}${ts.fail}${reset}${bold}, total: ${ts.pass + ts.fail}${reset}`);
+    log(`${bold}Time: ${timeFormat(ts.time)}${reset}`);
     return [ts.fail !== 0 ? 1 : 0, state];
 };
 export const anyLog = (f) => (s) => (state) => {
@@ -86,8 +86,8 @@ export const measure = (p) => (f) => (state) => {
 };
 export const main = async (io) => test({
     moduleMap: await loadModuleMap(io),
-    log: anyLog(io.console.log),
-    error: anyLog(io.console.error),
+    log: stdio(io), // anyLog(io.console.log),
+    error: stderr(io), // anyLog(io.console.error),
     measure: measure(io.performance),
     tryCatch: io.tryCatch,
     env: env(io),

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>;