functionalscript 0.3.10 → 0.3.12

package/issues/31-json.f.js

@@ -0,0 +1,241 @@
+"use strict";
+// JSON: https://www.json.org/json-en.html
+{
+    // null, [0x09, 0x0A], 0x0D, 0x20
+    const ws = () => ({ or: [
+            [],
+            ['\t', ws], // 0x09
+            ['\n', ws], // 0x0A
+            ['\r', ws], // 0x0D
+            [' ', ws], // 0x20
+        ] });
+    // null, 0x2B, 0x2D
+    const sign = { or: [
+            [],
+            '+', // 0x2B
+            '-', // 0x2D
+        ] };
+    // null, [0x30, 0x39]
+    const digits1 = () => ({ or: [
+            [],
+            digits // [0x30, 0x39]
+        ] });
+    // [0x30, 0x39]
+    const digits = () => [digit, digits1];
+    // null, 0x45, 0x65
+    const exponent = { or: [
+            [],
+            ['E', sign, digits], // 0x45
+            ['e', sign, digits], // 0x65
+        ] };
+    // null, 0x2E
+    const fraction = { or: [
+            [],
+            ['.', digits] // 0x2E
+        ] };
+    // [0x31, 0x39]
+    const onenine = [0x31, 0x39];
+    // [0x30, 0x39]
+    const digit = { or: [
+            '0', // 0x30
+            onenine, // [0x31, 0x39]
+        ] };
+    // null, 0x2C
+    const members2 = () => ({ or: [
+            [],
+            [',', ws, members1], // 0x2C
+        ] });
+    // 0x22
+    const members1 = () => [member1, members2];
+    // 0x22, 0x7D
+    const object1 = { or: [
+            [members1, '}'], // 0x22
+            '}', // 0x7D
+        ] };
+    // 0x7B
+    const object = ['{', ws, object1];
+    // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x5D, 0x66, 0x6E, 0x74, 0x7B
+    const array1 = () => ({ or: [
+            [element1, ']'], // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+            ']', // 0x5D
+        ] });
+    // 0x5B
+    const array = ['[', ws, array1];
+    // [0x30, 0x39], [0x41, 0x46], [0x61, 0x66]
+    const hex = { or: [
+            digit, // [0x30, 0x39]
+            [0x41, 0x46], // A..F
+            [0x61, 0x66], // a..f
+        ] };
+    // 0x22, 0x2F, 0x5C, 0x62, 0x66, 0x6E, 0x72, [0x74, 0x75]
+    const escape = { or: [
+            '"', // 0x22
+            '/', // 0x2F
+            '\\', // 0x5C
+            'b', // 0x62
+            'f', // 0x66
+            'n', // 0x6E
+            'r', // 0x72
+            't', // 0x74
+            ['u', hex, hex, hex, hex] // 0x75
+        ] };
+    // [0x20, 0x21], [0x23, 0x10FFFF]
+    const character = { or: [
+            [0x20, 0x21], // exclude '"' 0x22
+            [0x23, 0x5B], // exclude '\' 0x5C
+            [0x5D, 0x10FFFF], //
+            ['\\', escape], // 0x5C
+        ] };
+    // null, [0x20, 0x21], [0x23, 0x10FFFF]
+    const characters = () => ({ or: [
+            [],
+            [character, characters]
+        ] });
+    // 0x22
+    const string = ['"', characters, '"'];
+    // [0x30, 0x39]
+    const integer1 = { or: [
+            '0',
+            [onenine, digits1],
+        ] };
+    // 0x2D, [0x30, 0x39]
+    const integer = { or: [
+            ['-', integer1], // 0x2D
+            '0', // 0x30
+            [onenine, digits1], // [0x31, 0x39]
+        ] };
+    // 0x2D, [0x30, 0x39]
+    const number = [integer, fraction, exponent];
+    // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+    const value = { or: [
+            string, // 0x22
+            number, // 0x2D, [0x30, 0x39]
+            array, // 0x5B
+            'false', // 0x66
+            'null', // 0x6E
+            'true', // 0x74
+            object, // 0x7B
+        ] };
+    // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+    const element1 = [value, ws];
+    // [0x09, 0x0A], 0x0D, 0x20, 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+    const element = [ws, element1];
+    // 0x22
+    const member1 = [string, ws, ':', element];
+    const json = element;
+}
+// serializable
+{
+    //
+    const element = { id: 'element' };
+    const ws = { id: 'ws' };
+    const value = { id: 'value' };
+    const object = { id: 'object' };
+    const array = { id: 'array' };
+    const string = { id: 'string' };
+    const number = { id: 'number' };
+    const members = { id: 'members' };
+    const characters = { id: 'characters' };
+    const integer = { id: 'integer' };
+    const fraction = { id: 'fraction' };
+    const exponent = { id: 'exponent' };
+    const member = { id: 'member' };
+    const character = { id: 'character' };
+    const digit = { id: 'digit' };
+    const onenine = { id: 'onenine' };
+    const digits = { id: 'digits' };
+    const sign = { id: 'sign' };
+    const escape = { id: 'escape' };
+    const hex = { id: 'hex' };
+    const map = {
+        json: element,
+        element: [ws, value, ws],
+        ws: { or: [
+                [],
+                [' ', ws],
+                ['\t', ws],
+                ['\n', ws],
+                ['\r', ws],
+            ] },
+        value: { or: [
+                object,
+                array,
+                string,
+                number,
+                'true',
+                'false',
+                'null'
+            ] },
+        object: { or: [
+                ['{', ws, '}'],
+                ['{', members, '}'],
+            ] },
+        array: { or: [
+                ['[', ws, ']'],
+                ['[', element, ']'],
+            ] },
+        string: ['"', characters, '"'],
+        number: [integer, fraction, exponent],
+        members: { or: [
+                member,
+                [member, ',', members],
+            ] },
+        characters: { or: [
+                [],
+                [character, characters]
+            ] },
+        integer: { or: [
+                digit,
+                [onenine, digits],
+                ['-', digit],
+                ['-', onenine, digits],
+            ] },
+        fraction: { or: [
+                [],
+                ['.', digits]
+            ] },
+        exponent: { or: [
+                [],
+                ['E', sign, digits],
+                ['e', sign, digits],
+            ] },
+        member: [ws, string, ws, ':', element],
+        character: { or: [
+                [0x20, 0x21], // exclude '"' 0x22
+                [0x23, 0x5B], // exclude '\' 0x5C
+                [0x5D, 0x10FFFF],
+                ['\\', escape],
+            ] },
+        digit: { or: [
+                '0',
+                onenine,
+            ] },
+        onenine: [0x31, 0x39],
+        digits: { or: [
+                digit,
+                [digit, digits]
+            ] },
+        sign: { or: [
+                [],
+                '+',
+                '-',
+            ] },
+        escape: { or: [
+                '"',
+                '\\',
+                '/',
+                'b',
+                'f',
+                'n',
+                'r',
+                't',
+                ['u', hex, hex, hex, hex]
+            ] },
+        hex: { or: [
+                digit,
+                [0x41, 0x46], // A..F
+                [0x61, 0x66], // a..f
+            ] },
+    };
+    const _map = map;
+}

package/js/tokenizer/module.f.js

@@ -107,6 +107,7 @@ const union = def => a => b => {
 const rangeMapMerge = def => merge({
     union: union(def),
     equal: operator.strictEqual,
+    def,
 });
 const rangeFunc = r => f => def => fromRange(def)(r)(f);
 const scanRangeOp = def => f => [f(def), scanRangeOp(def)];
@@ -126,7 +127,11 @@ const create = (def) => (a) => {
 };
 const digitToBigInt = d => BigInt(d - digit0);
 const startNumber = digit => ({ s: 1n, m: digitToBigInt(digit), f: 0, es: 1, e: 0 });
-const startNegativeNumber = { s: -1n, m: 0n, f: 0, es: 1, e: 0 };
+/*
+const startNegativeNumber
+    : ParseNumberBuffer
+    = { s: -1n, m: 0n, f: 0, es: 1, e: 0 }
+*/
 const addIntDigit = digit => b => ({ ...b, m: b.m * 10n + digitToBigInt(digit) });
 const addFracDigit = digit => b => ({ ...b, m: b.m * 10n + digitToBigInt(digit), f: b.f - 1 });
 const addExpDigit = digit => b => ({ ...b, e: b.e * 10 + digit - digit0 });

package/nanvm-lib/tests/test.f.d.ts

@@ -41,6 +41,9 @@ declare const _default: {
             positive: () => void;
             nan: () => void;
         };
+        bigint: {
+            throw: () => number;
+        };
         array: {
             empty: () => void;
             single_number: () => void;
@@ -50,6 +53,7 @@ declare const _default: {
         object: {
             empty: () => void;
         };
+        function: () => void;
     };
 };
 export default _default;

package/nanvm-lib/tests/test.f.js

@@ -108,11 +108,9 @@ export default {
                 positive: () => e(op("2.3"))(2.3),
                 nan: () => nan("a")
             },
-            // TODO: bigint - handle TypeError exception for bigint. The test below (that follows
-            // current Rust implementation) is incorrect.
-            // bigint: {
-            //     nan: () => u_p_nan(0n)
-            // }
+            bigint: {
+                throw: () => op(0n),
+            },
             array: {
                 empty: () => e(op([]))(0),
                 single_number: () => e(op([2.3]))(2.3),
@@ -122,8 +120,8 @@ export default {
             object: {
                 empty: () => nan({})
                 // TODO: test objects with valueOf, toString functions - when Rust logic is implemented
-            }
-            // TODO: test Function - when Rust logic is implemented
+            },
+            function: () => nan(op(() => { }))
         };
     }
 };

package/nodejs/version/module.f.d.ts

@@ -1,4 +1,4 @@
-export type Buffer = {};
+export type Buffer = object;
 type Fs<T> = {
     readonly readFileSync: (name: string) => Buffer;
     readonly writeFileSync: (name: string, content: string) => T;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.10",
+  "version": "0.3.12",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

package/text/module.f.js

@@ -1,7 +1,7 @@
 import { msb, u8List, u8ListToVec } from "../types/bit_vec/module.f.js";
 import { flatMap } from "../types/list/module.f.js";
 import * as utf8 from "./utf8/module.f.js";
-import * as utf16 from "./utf16/module.f.js";
+import { stringToCodePointList, codePointListToString } from "./utf16/module.f.js";
 export const flat = (indent) => {
     const f = (prefix) => {
         const g = (item) => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
@@ -16,11 +16,11 @@ export const curly = (type) => (name) => (body) => [`${type} ${name}`, '{', body
  * @param s The input string to be converted.
  * @returns The resulting UTF-8 bit vector, MSB first.
  */
-export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(utf16.toCodePointList(utf16.stringToList(s))));
+export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(stringToCodePointList(s)));
 /**
  * Converts a UTF-8 bit vector with MSB first encoding to a string.
  *
  * @param msbV - The UTF-8 bit vector with MSB first encoding.
  * @returns The resulting string.
  */
-export const msbUtf8ToString = (msbV) => utf16.listToString(utf16.fromCodePointList(utf8.toCodePointList(u8List(msb)(msbV))));
+export const msbUtf8ToString = (msbV) => codePointListToString(utf8.toCodePointList(u8List(msb)(msbV)));

package/text/utf16/module.f.d.ts

@@ -1,8 +1,14 @@
 import { type List, type Thunk } from '../../types/list/module.f.ts';
-type U16 = number;
-type I32 = number;
-export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
-export declare const toCodePointList: (input: List<U16>) => List<I32>;
+export type U16 = number;
+/**
+ * [0, 0x10_FFFF]: 16+5 = 21 bits
+ *
+ * 121_0000_0000: 16+16+9 = 41 bits
+ */
+export type CodePoint = number;
+export declare const fromCodePointList: (input: List<CodePoint>) => Thunk<U16>;
+export declare const toCodePointList: (input: List<U16>) => List<CodePoint>;
 export declare const stringToList: (s: string) => List<U16>;
+export declare const stringToCodePointList: (input: string) => List<CodePoint>;
 export declare const listToString: (input: List<U16>) => string;
-export {};
+export declare const codePointListToString: (input: List<CodePoint>) => string;

package/text/utf16/module.f.js

@@ -60,6 +60,8 @@ export const stringToList = (s) => {
     };
     return at(0);
 };
+export const stringToCodePointList = (input) => toCodePointList(stringToList(input));
 export const listToString = fn(map(String.fromCharCode))
     .then(reduce(concat)(''))
     .result;
+export const codePointListToString = (input) => listToString(fromCodePointList(input));

package/text/utf16/test.f.js

@@ -1,4 +1,4 @@
-import { toCodePointList, fromCodePointList, stringToList, listToString } from "./module.f.js";
+import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from "./module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
@@ -130,6 +130,13 @@ export default {
                 throw result;
             }
         },
+        () => {
+            const cpList = stringToCodePointList("Hello world!😂🚜🚲");
+            const result = codePointListToString(cpList);
+            if (result !== "Hello world!😂🚜🚲") {
+                throw result;
+            }
+        },
         () => {
             const a = stringToList("Hello world!😂🚜🚲");
             const b = toCodePointList(a);

package/types/btree/find/module.f.d.ts

@@ -1,5 +1,5 @@
 import type { Leaf1, Leaf2, Branch3, Branch5, TNode } from '../types/module.f.ts';
-import type * as List from '../../list/module.f.ts';
+import type { List } from '../../list/module.f.ts';
 import { type Compare } from '../../function/compare/module.f.ts';
 import type { Index3, Index5 } from "../../array/module.f.ts";
 type FirstLeaf1<T> = readonly [Index3, Leaf1<T>];
@@ -10,7 +10,7 @@ type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T
 type PathItem3<T> = readonly [0 | 2, Branch3<T>];
 type PathItem5<T> = readonly [0 | 2 | 4, Branch5<T>];
 export type PathItem<T> = PathItem3<T> | PathItem5<T>;
-export type Path<T> = List.List<PathItem<T>>;
+export type Path<T> = List<PathItem<T>>;
 export type Result<T> = {
     readonly first: First<T>;
     readonly tail: Path<T>;

package/types/btree/remove/module.f.d.ts

@@ -1,4 +1,4 @@
-import type * as _ from '../types/module.f.ts';
-import type * as Cmp from '../../function/compare/module.f.ts';
-export declare const nodeRemove: <T>(c: Cmp.Compare<T>) => (node: _.TNode<T>) => _.Tree<T>;
-export declare const remove: <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>;
+import type { TNode, Tree } from '../types/module.f.ts';
+import type { Compare } from '../../function/compare/module.f.ts';
+export declare const nodeRemove: <T>(c: Compare<T>) => (node: TNode<T>) => Tree<T>;
+export declare const remove: <T>(c: Compare<T>) => (tree: Tree<T>) => Tree<T>;

package/types/btree/remove/module.f.js

@@ -1,9 +1,7 @@
-import * as find from "../find/module.f.js";
-import * as list from "../../list/module.f.js";
-const { fold, concat, next } = list;
-import * as n from "../../nullable/module.f.js";
-const { map } = n;
-const path = tail => n => {
+import { find } from "../find/module.f.js";
+import { fold, concat, next } from "../../list/module.f.js";
+import { map } from "../../nullable/module.f.js";
+const path = (tail) => (n) => {
     switch (n.length) {
         case 1: {
             return [n[0], { first: null, tail }];
@@ -19,7 +17,7 @@ const path = tail => n => {
         }
     }
 };
-const reduceValue0 = a => n => {
+const reduceValue0 = (a) => (n) => {
     const [, v1, n2] = n;
     if (a.length === 1) {
         switch (n2.length) {
@@ -38,7 +36,7 @@ const reduceValue0 = a => n => {
         return [a, v1, n2];
     }
 };
-const reduceValue2 = a => n => {
+const reduceValue2 = (a) => (n) => {
     const [n0, v1,] = n;
     if (a.length === 1) {
         switch (n0.length) {
@@ -57,7 +55,7 @@ const reduceValue2 = a => n => {
         return [n0, v1, a];
     }
 };
-const initValue0 = a => n => {
+const initValue0 = (a) => (n) => {
     const [, v1, n2] = n;
     if (a === null) {
         switch (n2.length) {
@@ -76,7 +74,7 @@ const initValue0 = a => n => {
         return [a, v1, n2];
     }
 };
-const initValue1 = a => n => {
+const initValue1 = (a) => (n) => {
     const [n0, v1] = n;
     if (a === null) {
         switch (n0.length) {
@@ -117,7 +115,7 @@ const reduce = fold(reduceX([reduceValue0, reduceValue2]));
 const initReduce = reduceX([initValue0, initValue1]);
 export const nodeRemove = (c) => (node) => {
     const f = () => {
-        const { first, tail } = find.find(c)(node);
+        const { first, tail } = find(c)(node);
         const branch = n => f => {
             const [v, p] = path(null)(n);
             return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) };

package/types/btree/remove/test.f.js

@@ -1,10 +1,10 @@
-import * as _ from "./module.f.js";
+import { nodeRemove } from "./module.f.js";
 import * as s from "../set/module.f.js";
 import { cmp } from "../../string/module.f.js";
 import * as json from "../../../json/module.f.js";
 import { sort } from "../../object/module.f.js";
 const set = (node) => (value) => s.set(cmp(value))(() => value)(node);
-const remove = (node) => (value) => _.nodeRemove(cmp(value))(node);
+const remove = (node) => (value) => nodeRemove(cmp(value))(node);
 const jsonStr = json.stringify(sort);
 const test = () => {
     let _map = ['1'];

package/types/btree/set/module.f.d.ts

@@ -1,3 +1,3 @@
-import type * as _ from '../types/module.f.ts';
-import type * as Cmp from '../../function/compare/module.f.ts';
-export declare const set: <T>(c: Cmp.Compare<T>) => (f: (value: T | null) => T) => (tree: _.Tree<T>) => _.TNode<T>;
+import type { TNode, Tree } from '../types/module.f.ts';
+import type { Compare } from '../../function/compare/module.f.ts';
+export declare const set: <T>(c: Compare<T>) => (f: (value: T | null) => T) => (tree: Tree<T>) => TNode<T>;

package/types/byte_set/test.f.js

@@ -1,4 +1,4 @@
-import * as _ from "./module.f.js";
+import { has, empty, set, setRange, unset, universe, complement, toRangeMap } from "./module.f.js";
 import { every, countdown, map, toArray } from "../list/module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
@@ -6,112 +6,112 @@ const stringify = json.stringify(sort);
 export default {
     has: [
         () => {
-            if (_.has(0)(_.empty)) {
-                throw _.empty;
+            if (has(0)(empty)) {
+                throw empty;
             }
-            if (_.has(1)(_.empty)) {
-                throw _.empty;
+            if (has(1)(empty)) {
+                throw empty;
             }
-            if (_.has(33)(_.empty)) {
-                throw _.empty;
+            if (has(33)(empty)) {
+                throw empty;
             }
         },
         () => {
-            const s = _.set(0)(_.empty);
+            const s = set(0)(empty);
             if (s !== 1n) {
                 throw s;
             }
-            if (!_.has(0)(s)) {
+            if (!has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (_.has(33)(s)) {
+            if (has(33)(s)) {
                 throw s;
             }
         },
         () => {
-            const s = _.set(33)(_.empty);
+            const s = set(33)(empty);
             if (s !== 8589934592n) {
                 throw s;
             }
-            if (_.has(0)(s)) {
+            if (has(0)(s)) {
                 throw s;
             }
-            if (_.has(1)(s)) {
+            if (has(1)(s)) {
                 throw s;
             }
-            if (!_.has(33)(s)) {
+            if (!has(33)(s)) {
                 throw s;
             }
         }
     ],
     setRange: () => {
-        const result = _.setRange([2, 5])(_.empty);
+        const result = setRange([2, 5])(empty);
         if (result !== 60n) {
             throw result;
         }
     },
     unset: [
         () => {
-            const a = _.set(0)(_.empty);
-            const result = _.unset(0)(a);
+            const a = set(0)(empty);
+            const result = unset(0)(a);
             if (result !== 0n) {
                 throw result;
             }
         },
         () => {
-            const a = _.set(255)(_.empty);
-            const result = _.unset(255)(a);
+            const a = set(255)(empty);
+            const result = unset(255)(a);
             if (result !== 0n) {
                 throw result;
             }
         }
     ],
     universe: () => {
-        const x = every(map((v) => _.has(v)(_.universe))(countdown(256)));
+        const x = every(map((v) => has(v)(universe))(countdown(256)));
         if (!x) {
             throw x;
         }
     },
     compliment: {
         empty: () => {
-            const r = _.complement(_.empty);
-            if (r !== _.universe) {
+            const r = complement(empty);
+            if (r !== universe) {
                 throw r;
             }
         },
         universe: () => {
-            const r = _.complement(_.universe);
-            if (r !== _.empty) {
+            const r = complement(universe);
+            if (r !== empty) {
                 throw r;
             }
         },
     },
     toRangeMap: [
         () => {
-            const result = stringify(toArray(_.toRangeMap(_.empty)('a')));
+            const result = stringify(toArray(toRangeMap(empty)('a')));
             if (result !== '[]') {
                 throw result;
             }
         },
         () => {
-            const s = _.set(0)(_.empty);
-            const result = stringify(toArray(_.toRangeMap(s)('a')));
+            const s = set(0)(empty);
+            const result = stringify(toArray(toRangeMap(s)('a')));
             if (result !== '[[["a"],0]]') {
                 throw result;
             }
         },
         () => {
-            const s = _.setRange([1, 2])(_.empty);
-            const result = stringify(toArray(_.toRangeMap(s)('a')));
+            const s = setRange([1, 2])(empty);
+            const result = stringify(toArray(toRangeMap(s)('a')));
             if (result !== '[[[],0],[["a"],2]]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(toArray(_.toRangeMap(_.universe)('a')));
+            const result = stringify(toArray(toRangeMap(universe)('a')));
             if (result !== '[[["a"],255]]') {
                 throw result;
             }

package/types/function/module.f.d.ts

@@ -1,7 +1,7 @@
 /**
  * A generic function type.
  */
-type Func<I, O> = (_: I) => O;
+export type Func<I, O> = (_: I) => O;
 /**
  * A postfix compose function.
  */