functionalscript 0.4.3 → 0.5.0

package/README.md

@@ -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 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 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).
 
 ## Vision
 

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

@@ -0,0 +1,12 @@
+import type { Rule as FRule } from '../module.f.ts';
+export type TerminalRange = number;
+export type Sequence = readonly string[];
+export type Variant = {
+    readonly [k in string]: string;
+};
+export type Rule = Variant | Sequence | TerminalRange;
+export type RuleSet = Readonly<Record<string, Rule>>;
+export declare const toData: (fr: FRule) => readonly [RuleSet, string];
+/**
+ * Either `{ variantItem: id }` or `id`.
+ */

package/bnf/data/module.f.js

@@ -0,0 +1,85 @@
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+const { entries } = Object;
+const find = (map) => (fr) => {
+    for (const [k, v] of entries(map)) {
+        if (v === fr) {
+            return k;
+        }
+    }
+    return undefined;
+};
+const newName = (map, name) => {
+    let i = 0;
+    let result = name;
+    while (result in map) {
+        result = name + i;
+        ++i;
+    }
+    return result;
+};
+const sequence = (list) => map => {
+    let result = [];
+    let set = {};
+    for (const fr of list) {
+        const [map1, set1, id] = toDataAdd(map)(fr);
+        map = map1;
+        set = { ...set, ...set1 };
+        result = [...result, id];
+    }
+    return [map, set, result];
+};
+const variant = (fr) => map => {
+    let set = {};
+    let rule = {};
+    for (const [k, v] of entries(fr)) {
+        const [m1, s, id] = toDataAdd(map)(v);
+        map = m1;
+        set = { ...set, ...s };
+        rule = { ...rule, [k]: id };
+    }
+    return [map, set, rule];
+};
+const data = (dr) => {
+    switch (typeof dr) {
+        case 'string': {
+            return sequence(toArray(stringToCodePointList(dr)));
+        }
+        case 'number':
+            return m => [m, {}, dr];
+        default:
+            if (dr instanceof Array) {
+                return sequence(dr);
+            }
+            return variant(dr);
+    }
+};
+const toDataAdd = (map) => (fr) => {
+    {
+        const id = find(map)(fr);
+        if (id !== undefined) {
+            return [map, {}, id];
+        }
+    }
+    const [dr, tmpId] = typeof fr === 'function' ? [fr(), fr.name] : [fr, ''];
+    const newRule = data(dr);
+    const id = newName(map, tmpId);
+    const map1 = { ...map, [id]: fr };
+    const [map2, set, rule] = newRule(map1);
+    return [map2, { ...set, [id]: rule }, id];
+};
+export const toData = (fr) => {
+    const [, ruleSet, id] = toDataAdd({})(fr);
+    return [ruleSet, id];
+};
+// type Dispatch = RangeMapArray<string>;
+/**
+ * Either `{ variantItem: id }` or `id`.
+ */
+/*
+type DispatchRule = SingleProperty<> | string
+
+type Dispatch = RangeMapArray<DispatchRule>
+
+type DispatchMap = { readonly[id in string]: Dispatch }
+*/

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

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

package/bnf/data/test.f.js

@@ -0,0 +1,8 @@
+import { classic, deterministic } from "../testlib.f.js";
+import { toData } from "./module.f.js";
+export default {
+    toData: () => {
+        const c = toData(classic());
+        const d = toData(deterministic());
+    }
+};

package/bnf/module.f.d.ts

@@ -0,0 +1,55 @@
+import { type Array2 } from '../types/array/module.f.ts';
+export type TerminalRange = number;
+export type Sequence = readonly Rule[];
+export type Variant = {
+    readonly [k in string]: Rule;
+};
+export type DataRule = Variant | Sequence | TerminalRange | string;
+export type LazyRule = () => DataRule;
+export type Rule = DataRule | LazyRule;
+export declare const max: string;
+export declare const rangeEncode: (a: number, b: number) => TerminalRange;
+export declare const oneEncode: (a: number) => TerminalRange;
+export declare const rangeDecode: (r: number) => Array2<number>;
+export declare const toSequence: (s: string) => readonly TerminalRange[];
+export declare const str: (s: string) => readonly TerminalRange[] | TerminalRange;
+export declare const set: (s: string) => RangeVariant;
+export declare const range: (ab: string) => TerminalRange;
+/**
+ * A set of terminal ranges compatible with the `Variant` rule.
+ */
+export type RangeVariant = {
+    readonly [k in string]: TerminalRange;
+};
+export declare const rangeToId: (r: TerminalRange) => string;
+export declare const remove: (range: TerminalRange, removeSet: RangeVariant) => RangeVariant;
+export type None = readonly [];
+export declare const none: None;
+export type Option<S> = {
+    none: None;
+    some: S;
+};
+export declare const option: <S extends Rule>(some: S) => Option<S>;
+export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;
+/**
+ * Repeat zero or more times.
+ *
+ * https://english.stackexchange.com/questions/506480/single-word-quantifiers-for-zero-or-more-like-cardinalities
+ * - zero or more - any, 0Plus
+ * - one or more - several, 1Plus
+ *
+ * Also see: https://arbs.nzcer.org.nz/types-numbers
+ */
+export declare const repeat0Plus: <T extends Rule>(some: T) => Repeat0Plus<T>;
+export type Repeat1Plus<T> = readonly [T, Repeat0Plus<T>];
+/**
+ * Repeat one or more times.
+ */
+export declare const repeat1Plus: <T extends Rule>(some: T) => Repeat1Plus<T>;
+export type Join1Plus<T, S> = readonly [T, Repeat0Plus<readonly [S, T]>];
+export declare const join1Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Join1Plus<T, S>;
+export type Join0Plus<T, S> = Option<readonly [T, Repeat0Plus<readonly [S, T]>]>;
+export declare const join0Plus: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;
+export type Repeat<T> = readonly T[];
+export declare const repeat: (n: number) => <T extends Rule>(some: T) => Repeat<T>;
+export declare const isEmpty: (rule: Rule) => boolean;

package/bnf/module.f.js

@@ -0,0 +1,98 @@
+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";
+//
+const { fromEntries, values } = Object;
+const { fromCodePoint } = String;
+/**
+ * Two 24 bit numbers can be fit into one JS number (53 bit).
+ */
+const offset = 24;
+const mask = (1 << offset) - 1;
+const isValid = (r) => r >= 0 && r <= mask;
+export const max = codePointListToString([0x10FFFF]);
+export const rangeEncode = (a, b) => {
+    if (!isValid(a) || !isValid(b) || a > b) {
+        throw `Invalid range ${a} ${b}.`;
+    }
+    return (a << offset) | b;
+};
+export const oneEncode = (a) => rangeEncode(a, a);
+export const rangeDecode = (r) => [r >> offset, r & mask];
+const mapOneEncode = map(oneEncode);
+export const toSequence = (s) => toArray(mapOneEncode(stringToCodePointList(s)));
+export const str = (s) => {
+    const x = toSequence(s);
+    return x.length === 1 ? x[0] : x;
+};
+const mapEntry = map((v) => [fromCodePoint(v), oneEncode(v)]);
+export const set = (s) => fromEntries(toArray(mapEntry(stringToCodePointList(s))));
+export const range = (ab) => {
+    const a = toArray(stringToCodePointList(ab));
+    if (!isArray2(a)) {
+        throw `Invalid range ${ab}.`;
+    }
+    return rangeEncode(...a);
+};
+export const rangeToId = (r) => {
+    const ab = rangeDecode(r);
+    const [a, b] = ab;
+    const cp = a === b ? [a] : ab;
+    return fromCodePoint(...cp);
+};
+const rangeToEntry = (r) => [rangeToId(r), r];
+const toVariantRangeSet = (r) => fromEntries(r.map(rangeToEntry));
+const removeOne = (list, ab) => {
+    const [a, b] = rangeDecode(ab);
+    let result = [];
+    for (const ab0 of list) {
+        const [a0, b0] = rangeDecode(ab0);
+        if (a0 < a) {
+            // [a0
+            //     ]a
+            result = [...result, rangeEncode(a0, Math.min(b0, a - 1))];
+        }
+        if (b < b0) {
+            //    b0]
+            // b[
+            result = [...result, rangeEncode(Math.max(b + 1, a0), b0)];
+        }
+    }
+    return result;
+};
+export const remove = (range, removeSet) => {
+    let result = [range];
+    for (const r of values(removeSet)) {
+        result = removeOne(result, r);
+    }
+    return toVariantRangeSet(result);
+};
+export const none = [];
+export const option = (some) => ({
+    none,
+    some,
+});
+/**
+ * Repeat zero or more times.
+ *
+ * https://english.stackexchange.com/questions/506480/single-word-quantifiers-for-zero-or-more-like-cardinalities
+ * - zero or more - any, 0Plus
+ * - one or more - several, 1Plus
+ *
+ * Also see: https://arbs.nzcer.org.nz/types-numbers
+ */
+export const repeat0Plus = (some) => {
+    const r = () => option([some, r]);
+    return r;
+};
+/**
+ * Repeat one or more times.
+ */
+export const repeat1Plus = (some) => [some, repeat0Plus(some)];
+export const join1Plus = (some, separator) => [some, repeat0Plus([separator, some])];
+export const join0Plus = (some, separator) => option(join1Plus(some, separator));
+export const repeat = (n) => (some) => toArray(listRepeat(some)(n));
+export const isEmpty = (rule) => {
+    const d = typeof rule === 'function' ? rule() : rule;
+    return d === '' || (d instanceof Array && d.length === 0);
+};

package/bnf/test.f.d.ts

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

package/bnf/test.f.js

@@ -0,0 +1,7 @@
+import { classic, deterministic } from "./testlib.f.js";
+export default {
+    test: () => {
+        classic();
+        deterministic();
+    }
+};

package/bnf/testlib.f.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from './module.f.ts';
+export declare const classic: () => Rule;
+export declare const deterministic: () => Rule;

package/bnf/{tag/test.f.js → testlib.f.js}

@@ -1,5 +1,5 @@
-import { join0, none, option, range, repeat0, set } from "./module.f.js";
-const _classic = () => {
+import { join0Plus, max, none, option, range, remove, repeat, repeat0Plus, set } from "./module.f.js";
+export const classic = () => {
     const json = () => [element];
     const value = () => ({
         object,
@@ -34,9 +34,9 @@ const _classic = () => {
         characters: [character, characters],
     });
     const character = () => ({
-        0: 0x20000021n,
-        1: 0x2300005bn,
-        2: 0x5d10ffffn,
+        0: 0x20_000021,
+        1: 0x23_00005B,
+        2: 0x5D_10FFFF,
         escape: ['\\', escape],
     });
     const escape = () => ({
@@ -63,7 +63,7 @@ const _classic = () => {
         '0': '0',
         onenine,
     });
-    const onenine = range('12');
+    const onenine = range('19');
     const fraction = () => ({
         none,
         digits: ['.', digits],
@@ -86,53 +86,57 @@ const _classic = () => {
     });
     return json;
 };
-const _deterministic = () => {
-    const onenine = range('12');
-    const digit = {
-        '0': '0',
-        onenine,
-    };
-    const hex = {
-        digit,
-        AF: range('AF'),
-        af: range('af'),
-    };
-    const escape = {
-        ...set('"\\/bfnrt'),
-        u: ['u', hex, hex, hex, hex],
-    };
-    const character = {
-        0: 0x20000021n,
-        1: 0x2300005bn,
-        2: 0x5d10ffffn,
-        escape: ['\\', escape],
-    };
-    const characters = repeat0(character);
-    const string = ['"', characters, '"'];
-    const digits0 = repeat0(digit);
+export const deterministic = () => {
+    const onenine = range('19');
+    const digit = range('09');
+    const string = [
+        '"',
+        repeat0Plus({
+            ...remove(range(` ${max}`), set('"\\')),
+            escape: [
+                '\\',
+                {
+                    ...set('"\\/bfnrt'),
+                    u: [
+                        'u',
+                        ...repeat(4)({
+                            digit,
+                            AF: range('AF'),
+                            af: range('af'),
+                        })
+                    ],
+                }
+            ],
+        }),
+        '"'
+    ];
+    const digits0 = repeat0Plus(digit);
     const digits = [digit, digits0];
-    const integer = [option('-'), {
-            '0': '0',
+    const number = [
+        option('-'),
+        {
+            0: '0',
             onenine: [onenine, digits0],
-        }];
-    const fraction = option(['.', digits]);
-    const sign = option(set('+-'));
-    const exponent = option([set('Ee'), sign, digits]);
-    const number = [integer, fraction, exponent];
-    const ws = repeat0(set(' \n\r\t'));
+        },
+        option(['.', digits]),
+        option([set('Ee'), option(set('+-')), digits])
+    ];
+    const ws = repeat0Plus(set(' \n\r\t'));
+    const commaJoin0Plus = ([open, close], a) => [
+        open,
+        ws,
+        join0Plus([a, ws], [',', ws]),
+        close,
+    ];
     const value = () => ({
-        object,
-        array,
+        object: commaJoin0Plus('{}', [string, ws, ':', ws, value]),
+        array: commaJoin0Plus('[]', value),
         string,
         number,
         true: 'true',
         false: 'false',
         null: 'null'
     });
-    const commaJoin0 = ([open, close], a) => [open, ws, join0([a, ws], [',', ws]), close];
-    const array = commaJoin0('[]', value);
-    const member = [string, ws, ':', ws, value];
-    const object = commaJoin0('{}', member);
     const json = [ws, value, ws];
     return json;
 };

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

@@ -65,4 +65,12 @@ export declare const secp256k1: Init;
  * https://neuromancer.sk/std/secg/secp256r1
  */
 export declare const secp256r1: Init;
+/**
+ * https://neuromancer.sk/std/secg/secp384r1
+ */
+export declare const secp384r1: Init;
+/**
+ * https://neuromancer.sk/std/secg/secp521r1
+ */
+export declare const secp521r1: Init;
 export {};

package/crypto/secp/module.f.js

@@ -124,3 +124,33 @@ export const secp256r1 = {
     ],
     n: 0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551n,
 };
+/**
+ * https://neuromancer.sk/std/secg/secp384r1
+ */
+export const secp384r1 = {
+    p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000ffffffffn,
+    a: [
+        0xb3312fa7e23ee7e4988e056be3f82d19181d9c6efe8141120314088f5013875ac656398d8a2ed19d2a85c8edd3ec2aefn, //< b
+        0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffeffffffff0000000000000000fffffffcn, //< a
+    ],
+    g: [
+        0xaa87ca22be8b05378eb1c71ef320ad746e1d3b628ba79b9859f741e082542a385502f25dbf55296c3a545e3872760ab7n, //< x
+        0x3617de4a96262c6f5d9e98bf9292dc29f8f41dbd289a147ce9da3113b5f0b8c00a60b1ce1d7e819d7a431d7c90ea0e5fn, //< y
+    ],
+    n: 0xffffffffffffffffffffffffffffffffffffffffffffffffc7634d81f4372ddf581a0db248b0a77aecec196accc52973n,
+};
+/**
+ * https://neuromancer.sk/std/secg/secp521r1
+ */
+export const secp521r1 = {
+    p: 0x01ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffn,
+    a: [
+        0x0051953eb9618e1c9a1f929a21a0b68540eea2da725b99b315f3b8b489918ef109e156193951ec7e937b1652c0bd3bb1bf073573df883d2c34f1ef451fd46b503f00n, //< b
+        0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffcn, //< a
+    ],
+    g: [
+        0x00c6858e06b70404e9cd9e3ecb662395b4429c648139053fb521f828af606b4d3dbaa14b5e77efe75928fe1dc127a2ffa8de3348b3c1856a429bf97e7e31c2e5bd66n,
+        0x011839296a789a3bc0045c8a5fb42c7d1bd998f54449579b446817afbd17273e662c97ee72995ef42640c550b9013fad0761353c7086a272c24088be94769fd16650n,
+    ],
+    n: 0x01fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffa51868783bf2f966b7fcc0148f709a5d03bb5c9b8899c47aebb6fb71e91386409n
+};

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

@@ -1,5 +1,8 @@
 declare const _default: {
     example: () => void;
     test: () => void;
+    poker: () => {
+        [k: string]: () => void;
+    };
 };
 export default _default;

package/crypto/secp/test.f.js

@@ -1,4 +1,58 @@
-import { curve, secp256k1, secp192r1, secp256r1, eq } from "./module.f.js";
+import { prime_field } from "../prime_field/module.f.js";
+import { curve, secp256k1, secp192r1, secp256r1, eq, secp384r1, secp521r1 } from "./module.f.js";
+const poker = (param) => () => {
+    // (c ^ x) ^ y = c ^ (x * y)
+    // c ^ ((x * y) * (1/x * 1/y)) = c
+    const { g, n } = param;
+    const { mul, y } = curve(param);
+    const f = (m) => (pList) => pList.map(i => mul(i)(m));
+    //
+    const pf = prime_field(n);
+    //           0        1        2        3        4        5        6        7
+    const sA = 0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdefn % n;
+    const sB = 0xfedcba98fedcba98fedcba98fedcba98fedcba98fedcba98fedcba98fedcba98n % n;
+    // "22d3ad011aec6aabdb3d3d47636f3e2859de02298c87a496"
+    // "2b359de5cfb5937a5610d565dceaef2a760ceeaec96e68140757f0c8371534e0"
+    // "1359162ede91207ccaea1de94afc63c1db5a967c1e6e21f91ef9f077f20a46b6"
+    const rA = pf.reciprocal(sA);
+    // "e1e768c7427cf5bafd58756df9b54b9ec2558201f129f4ab"
+    // "edaf7ede285c3da723c54fcdaa3b631f626681f884d8f41fae55c4f552bb551e"
+    // "6ca248e88c124478975b57c4c3ca682bd8be0f0d9f11593d01273d9ceebdb735"
+    const rB = pf.reciprocal(sB);
+    //
+    let d = [];
+    for (let i = 0n; i < 52n; ++i) {
+        let nonce = 0n; // can be a random number in a range [`0`, `p >> 6n`).
+        let x = 0n;
+        let yi;
+        while (true) {
+            x = i | (nonce << 6n);
+            yi = y(x);
+            if (yi !== null) {
+                break;
+            }
+            ++nonce;
+        }
+        d = [...d, [x, yi]];
+    }
+    //
+    const dA = f(sA)(d);
+    const dAB = f(sB)(dA);
+    const dB = f(rA)(dAB);
+    const dN = f(rB)(dB);
+    //
+    let m = 0n;
+    for (const p of dN) {
+        if (p === null) {
+            throw 'null';
+        }
+        const x = p[0] & 0x3fn;
+        if (x !== m) {
+            throw [p[0], x, m];
+        }
+        ++m;
+    }
+};
 export default {
     example: () => {
         const curveParams = {
@@ -17,7 +71,7 @@ export default {
         const test_curve = c => {
             const { g } = c;
             const { mul, neg, pf: { abs }, y: yf, nf: { p: n } } = curve(c);
-            const point_check = p => {
+            const point_check = (p) => {
                 if (p === null) {
                     throw 'p === null';
                 }
@@ -32,7 +86,7 @@ export default {
             };
             point_check(g);
             point_check(neg(g));
-            const test_mul = p => {
+            const test_mul = (p) => {
                 if (mul(p)(0n) !== null) {
                     throw 'O';
                 }
@@ -68,5 +122,15 @@ export default {
         test_curve(secp256k1);
         test_curve(secp192r1);
         test_curve(secp256r1);
+        test_curve(secp384r1);
+        test_curve(secp521r1);
+    },
+    poker: () => {
+        const c = {
+            secp192r1,
+            //secp256k1,
+            //secp256r1,
+        };
+        return Object.fromEntries(Object.entries(c).map(([k, v]) => [k, poker(v)]));
     }
 };

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

@@ -0,0 +1,10 @@
+import type * as djs from '../module.f.ts';
+export type AstModule = [readonly string[], AstBody];
+export type AstConst = djs.Primitive | AstModuleRef | AstArray | AstObject;
+export type AstModuleRef = ['aref' | 'cref', number];
+export type AstArray = ['array', readonly AstConst[]];
+export type AstObject = {
+    readonly [k in string]: AstConst;
+};
+export type AstBody = readonly AstConst[];
+export declare const run: (body: AstBody) => (args: djs.Array) => djs.Unknown;

package/djs/ast/module.f.js

@@ -0,0 +1,52 @@
+import { concat, fold, last, map, take, toArray } from "../../types/list/module.f.js";
+import { fromEntries } from "../../types/object/module.f.js";
+const { entries } = Object;
+const foldOp = ast => state => {
+    const djs = toDjs(state)(ast);
+    return { ...state, consts: concat(state.consts)([djs]) };
+};
+const foldAstObjectOp = entry => state => {
+    const e = concat(state.entries)([[entry[0], (toDjs(state.runState)(entry[1]))]]);
+    return { ...state, entries: e };
+};
+const toDjs = state => ast => {
+    switch (typeof ast) {
+        case 'boolean':
+        case 'number':
+        case 'string':
+        case 'bigint': {
+            return ast;
+        }
+        default: {
+            if (ast === null) {
+                return ast;
+            }
+            if (ast === undefined) {
+                return ast;
+            }
+            if (ast instanceof Array) {
+                switch (ast[0]) {
+                    case 'aref': {
+                        return state.args[ast[1]];
+                    }
+                    case 'cref': {
+                        return last(null)(take(ast[1] + 1)(state.consts));
+                    }
+                    case 'array': {
+                        return toArray(map(toDjs(state))(ast[1]));
+                    }
+                }
+            }
+            const e = fold(foldAstObjectOp)({ runState: state, entries: null })(entries(ast)).entries;
+            return fromEntries(e);
+        }
+    }
+};
+export const run = body => args => {
+    const state = fold(foldOp)({ body, args, consts: null })(body);
+    return last(null)(state.consts);
+};
+// for functions
+// export const astBodyToAstConst
+//     :(body: AstBody) => (args: AstArray) => AstConst
+//     = body => args => todo()

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

@@ -0,0 +1,8 @@
+declare const _default: {
+    test: () => void;
+    testCref: () => void;
+    testAref: () => void;
+    testArray: () => void;
+    testObj: () => void;
+};
+export default _default;