functionalscript 0.4.2 → 0.4.4

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/crypto/sha2/module.f.d.ts

@@ -1,5 +1,6 @@
 import type { Array16, Array8 } from '../../types/array/module.f.ts';
 import { type Vec } from '../../types/bit_vec/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
 export type V8 = Array8<bigint>;
 export type V16 = Array16<bigint>;
 /**
@@ -40,6 +41,14 @@ export type Base = {
  * ```
  */
 export type Sha2 = {
+    /**
+     * A hash length.
+     */
+    readonly hashLength: bigint;
+    /**
+     * An internal block length.
+     */
+    readonly blockLength: bigint;
     /**
      * Initial state of the SHA-2 algorithm.
      */
@@ -60,6 +69,7 @@ export type Sha2 = {
      */
     readonly end: (state: State) => bigint;
 };
+export declare const computeSync: ({ append, init, end }: Sha2) => (list: List<Vec>) => Vec;
 export declare const base32: Base;
 export declare const base64: Base;
 /** SHA-256 */

package/crypto/sha2/module.f.js

@@ -1,5 +1,7 @@
 import { mask } from "../../types/bigint/module.f.js";
 import { vec, length, empty, msb } from "../../types/bit_vec/module.f.js";
+import { flip } from "../../types/function/module.f.js";
+import { fold } from "../../types/list/module.f.js";
 const { concat, popFront, front } = msb;
 const lastOne = vec(1n)(1n);
 const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
@@ -138,6 +140,7 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
         },
         end: (hashLength) => {
             const offset = (bitLength << 3n) - hashLength;
+            const result = vec(hashLength);
             return (state) => {
                 const { len, remainder } = state;
                 let { hash } = state;
@@ -148,12 +151,14 @@ const base = ({ logBitLen, k, bs0, bs1, ss0, ss1 }) => {
                     hash = compress(hash)(u);
                     u = 0n;
                 }
-                return fromV8(compress(hash)(u | (len + rLen))) >> offset;
+                return result(fromV8(compress(hash)(u | (len + rLen))) >> offset);
             };
         }
     };
 };
-const sha2 = ({ append, end }, hash, hashLength) => ({
+const sha2 = ({ append, end, chunkLength }, hash, hashLength) => ({
+    hashLength,
+    blockLength: chunkLength,
     init: {
         hash,
         len: 0n,
@@ -162,6 +167,10 @@ const sha2 = ({ append, end }, hash, hashLength) => ({
     append,
     end: end(hashLength),
 });
+export const computeSync = ({ append, init, end }) => {
+    const f = fold(flip(append))(init);
+    return (list) => end(f(list));
+};
 export const base32 = base({
     logBitLen: 5n,
     k: [

package/crypto/sha2/test.f.js

@@ -1,7 +1,8 @@
 import { msbUtf8 } from "../../text/module.f.js";
 import { empty, msb, vec } from "../../types/bit_vec/module.f.js";
+import { map } from "../../types/list/module.f.js";
 import { repeat } from "../../types/monoid/module.f.js";
-import { base32, base64, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from "./module.f.js";
+import { base32, base64, computeSync, sha224, sha256, sha384, sha512, sha512x224, sha512x256, } from "./module.f.js";
 const { concat: beConcat } = msb;
 const checkEmpty = ({ init, end }) => (x) => {
     const result = end(init);
@@ -22,7 +23,7 @@ export default {
                     const result = fromV8(compress(sha256.init.hash)(e));
                     const x = 0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n;
                     if (result !== x) {
-                        throw [result, x];
+                        throw [result.toString(16), x.toString(16)];
                     }
                 },
                 s224: () => {
@@ -70,29 +71,35 @@ export default {
         }
     },
     sha2: {
-        sha256: () => checkEmpty(sha256)(0xe3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n),
-        sha224: () => checkEmpty(sha224)(0xd14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn),
-        sha512: () => checkEmpty(sha512)(0xcf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en),
-        sha384: () => checkEmpty(sha384)(0x38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn),
-        sha512x256: () => checkEmpty(sha512x256)(0xc672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an),
-        sha512x224: () => checkEmpty(sha512x224)(0x6ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n),
+        sha256: () => checkEmpty(sha256)(0x1e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855n),
+        sha224: () => checkEmpty(sha224)(0x1d14a028c2a3a2bc9476102bb288234c415a2b01f828ea62ac5b3e42fn),
+        sha512: () => checkEmpty(sha512)(0x1cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3en),
+        sha384: () => checkEmpty(sha384)(0x138b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95bn),
+        sha512x256: () => checkEmpty(sha512x256)(0x1c672b8d1ef56ed28ab87c3622c5114069bdd3ad7b8f9737498d0c01ecef0967an),
+        sha512x224: () => checkEmpty(sha512x224)(0x16ed0dd02806fa89e25de060c19d3ac86cabb87d6a0ddd05c333b84f4n),
     },
     utf8: [
         () => {
-            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);
-            if (h !== 0x730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525n) {
-                throw h;
+            const e = 0x1730e109bd7a8a32b1cb9d9a09aa2325d2430587ddbc0c38bad911525n;
+            {
+                const s = msbUtf8("The quick brown fox jumps over the lazy dog");
+                const h = computeSync(sha224)([s]);
+                if (h !== e) {
+                    throw h;
+                }
+            }
+            {
+                const s = ['The', ' quick', ' brown', ' fox', ' jumps', ' over', ' the', ' lazy', ' dog'];
+                const h = computeSync(sha224)(map(msbUtf8)(s));
+                if (h !== e) {
+                    throw h;
+                }
             }
         },
         () => {
             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);
-            if (h !== 0x619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
+            const h = computeSync(sha224)([s]);
+            if (h !== 0x1619cba8e8e05826e9b8c519c0a5c68f4fb653e8a3d8aa04bb2c8cd4cn) {
                 throw h;
             }
         },
@@ -104,7 +111,7 @@ export default {
             let state = sha256.init;
             state = sha256.append(state)(s);
             const h = sha256.end(state);
-            if (h !== 0xb94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
+            if (h !== 0x1b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9n) {
                 throw h;
             }
         }
@@ -117,7 +124,7 @@ export default {
                 let state = sha256.init;
                 state = sha256.append(state)(r);
                 const h = sha256.end(state);
-                if (h >> 224n !== 0x8a83665fn) {
+                if (h >> 224n !== 0x18a83665fn) {
                     throw h;
                 }
             },
@@ -126,7 +133,7 @@ export default {
                 let state = sha256.init;
                 state = sha256.append(state)(r);
                 const h = sha256.end(state);
-                if (h !== 0x3138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
+                if (h !== 0x13138bb9bc78df27c473ecfd1410f7bd45ebac1f59cf3ff9cfe4db77aab7aedd3n) {
                     throw h;
                 }
             }

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;

package/djs/ast/test.f.js

@@ -0,0 +1,41 @@
+import * as list from "../../types/object/module.f.js";
+const { sort } = list;
+import * as shared from "./module.f.js";
+import { stringify } from "../serializer/module.f.js";
+export default {
+    test: () => {
+        const djs = shared.run([1])([]);
+        const result = stringify(sort)(djs);
+        if (result !== '1') {
+            throw result;
+        }
+    },
+    testCref: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '4') {
+            throw result;
+        }
+    },
+    testAref: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '14') {
+            throw result;
+        }
+    },
+    testArray: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '[14,4]') {
+            throw result;
+        }
+    },
+    testObj: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '{"key":{"key2":[14,4]}}') {
+            throw result;
+        }
+    },
+};

package/djs/module.f.d.ts

@@ -1,17 +1,7 @@
-import * as list from '../types/list/module.f.ts';
-import type * as O from '../types/object/module.f.ts';
-type Object = {
+import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
+export type Object = {
     readonly [k in string]: Unknown;
 };
-type Array = readonly Unknown[];
-type Unknown = Object | boolean | string | number | null | Array | bigint | undefined;
-type Entry = O.Entry<Unknown>;
-type Entries = list.List<Entry>;
-type MapEntries = (entries: Entries) => Entries;
-export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>;
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- */
-export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
-export {};
+export type Array = readonly Unknown[];
+export type Primitive = JsonPrimitive | bigint | undefined;
+export type Unknown = Primitive | Object | Array;

package/djs/module.f.js

@@ -1,62 +1 @@
-import * as list from "../types/list/module.f.js";
-const { flat, map } = list;
-import * as string from "../types/string/module.f.js";
-const { concat } = string;
-import * as f from "../types/function/module.f.js";
-const { compose, fn } = f;
-const { entries } = Object;
-import * as bi from "../types/bigint/module.f.js";
-const { serialize: bigintSerialize } = bi;
-import * as j from "../json/serializer/module.f.js";
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
-import * as djs from "./serializer/module.f.js";
-const { undefinedSerialize } = djs;
-const colon = [':'];
-export const serialize = sort => {
-    const propertySerialize = ([k, v]) => flat([
-        stringSerialize(k),
-        colon,
-        f(v)
-    ]);
-    const mapPropertySerialize = map(propertySerialize);
-    const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
-        .result;
-    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 === undefined) {
-                    return undefinedSerialize;
-                }
-                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
- */
-export const stringify = sort => compose(serialize(sort))(concat);
+export {};

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

@@ -1,12 +1,12 @@
 import * as result from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
-import type * as tokenizerT from '../tokenizer/module.f.ts';
-export type DjsModule = [readonly string[], readonly DjsConst[]];
-export type DjsConst = boolean | string | number | null | bigint | undefined | DjsModuleRef | DjsArray | DjsObject;
-type DjsModuleRef = ['aref' | 'cref', number];
-type DjsArray = ['array', readonly DjsConst[]];
-export type DjsObject = {
-    readonly [k in string]: DjsConst;
+import type { DjsToken } from '../tokenizer/module.f.ts';
+import { type Map } from '../../types/map/module.f.ts';
+import type { Fs } from '../../io/module.f.ts';
+import type { AstModule } from '../ast/module.f.ts';
+export type ParseContext = {
+    readonly fs: Fs;
+    readonly complete: Map<result.Result<AstModule, string>>;
+    readonly stack: List<string>;
 };
-export declare const parse: (tokenList: List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>;
-export {};
+export declare const parseFromTokens: (tokenList: List<DjsToken>) => result.Result<AstModule, string>;

package/djs/parser/module.f.js

@@ -1,8 +1,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/map/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { fromMap } = o;
+import { fromMap } from "../../types/object/module.f.js";
 const parseInitialOp = token => state => {
     switch (token.kind) {
         case 'ws':
@@ -59,8 +58,8 @@ const parseConstOp = token => state => {
         case 'id': {
             if (at(token.value)(state.module.refs) !== null)
                 return { state: 'error', message: 'duplicate id' };
-            let cref = ['cref', length(state.module.consts)];
-            let refs = setReplace(token.value)(cref)(state.module.refs);
+            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' };
@@ -86,8 +85,8 @@ const parseImportOp = token => state => {
             if (at(token.value)(state.module.refs) !== null) {
                 return { state: 'error', message: 'duplicate id' };
             }
-            let aref = ['aref', length(state.module.modules)];
-            let refs = setReplace(token.value)(aref)(state.module.refs);
+            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' };
@@ -130,7 +129,7 @@ const pushKey = state => key => {
 };
 const pushValue = state => value => {
     if (state.top === null) {
-        let consts = concat(state.module.consts)([value]);
+        const consts = 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 } };
@@ -321,7 +320,7 @@ const foldOp = token => state => {
             }
     }
 };
-export const parse = (tokenList) => {
+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)]);