functionalscript 0.1.609 → 0.2.1

package/out/json/parser/test.f.mjs

@@ -0,0 +1,321 @@
+import * as parser from './module.f.mjs';
+import * as tokenizer from '../tokenizer/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+const { toArray } = list;
+import * as json from '../module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { sort } = o;
+import * as encoding from '../../text/utf16/module.f.mjs';
+/** @type {(s: string) => readonly tokenizer.JsonToken[]} */
+const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
+const stringify = json.stringify(sort);
+export default {
+    valid: [
+        () => {
+            const tokenList = tokenizeString('null');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",null]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('true');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",true]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('false');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",false]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('0.1');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",0.1]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('1.1e+2');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",110]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('"abc"');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok","abc"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",[]]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[1]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",[1]]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[[]]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",[[]]]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[0,[1,[2,[]]],3]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",[0,[1,[2,[]]],3]]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",{}]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[{}]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",[{}]]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":true,"b":false,"c":null}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",{"a":true,"b":false,"c":null}]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"a":{"b":{"c":["d"]}}}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["ok",{"a":{"b":{"c":["d"]}}}]') {
+                throw result;
+            }
+        }
+    ],
+    invalid: [
+        () => {
+            const tokenList = tokenizeString('');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected end"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('"123');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[,]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[1 2]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[1,,2]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[]]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('["a"');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected end"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[1,]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[,1]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[:]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString(']');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{,}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{1:2}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1"2}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1"::2}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2,,"3":4');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{}}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected end"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"1":2,}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{,"1":2}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('[{]}');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{[}]');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('10-5');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+    ]
+};

package/out/json/serializer/module.f.d.mts

@@ -0,0 +1,36 @@
+/** @type {(_: string) => list.List<string>} */
+export const stringSerialize: (_: string) => list.List<string>;
+/** @type {(_: number) => list.List<string>} */
+export const numberSerialize: (_: number) => list.List<string>;
+export const nullSerialize: string[];
+/** @type {(_: boolean) => list.List<string>} */
+export const boolSerialize: (_: boolean) => list.List<string>;
+export const objectWrap: (input: list.List<list.List<string>>) => list.List<string>;
+export const arrayWrap: (input: list.List<list.List<string>>) => list.List<string>;
+/**
+ * <T>
+ */
+export type Obj<T> = { readonly [k in string]: Unknown<T>; };
+/**
+ * <T>
+ */
+export type Arr<T> = readonly Unknown<T>[];
+export type Primitive = boolean | string | number | null;
+/**
+ * <T>
+ */
+export type Unknown<T> = Arr<T> | Obj<T> | null | T;
+/**
+ * <T>
+ */
+export type Entry<T> = O.Entry<Unknown<T>>;
+/**
+ * <T>
+ */
+export type Entries<T> = (list.List<Entry<T>>);
+/**
+ * <T>
+ */
+export type MapEntries<T> = (entries: Entries<T>) => Entries<T>;
+import * as list from '../../types/list/module.f.mjs';
+import * as O from '../../types/object/module.f.mjs';

package/out/json/serializer/module.f.mjs

@@ -0,0 +1,67 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../../types/list/module.f.mjs';
+const { flat, reduce, empty } = list;
+import * as O from '../../types/object/module.f.mjs';
+import * as Operator from '../../types/function/operator/module.f.mjs';
+/**
+ * @template T
+ * @typedef {{
+ *  readonly [k in string]: Unknown<T>
+ * }} Obj<T>
+ */
+/**
+ * @template T
+ *  @typedef {readonly Unknown<T>[]} Arr<T>
+ */
+/**
+ * @typedef {|
+* boolean |
+* string |
+* number |
+* null
+* } Primitive
+*/
+/**
+ * @template T
+ * @typedef {|
+ * Arr<T>|
+ * Obj<T>|
+ * null|
+ * T
+ * } Unknown<T>
+ */
+const jsonStringify = JSON.stringify;
+/** @type {(_: string) => list.List<string>} */
+export const stringSerialize = input => [jsonStringify(input)];
+/** @type {(_: number) => list.List<string>} */
+export const numberSerialize = input => [jsonStringify(input)];
+export const nullSerialize = ['null'];
+const trueSerialize = ['true'];
+const falseSerialize = ['false'];
+/** @type {(_: boolean) => list.List<string>} */
+export const boolSerialize = value => value ? trueSerialize : falseSerialize;
+const comma = [','];
+/** @type {Operator.Reduce<list.List<string>>} */
+const joinOp = b => prior => flat([prior, comma, b]);
+/** @type {(input: list.List<list.List<string>>) => list.List<string>} */
+const join = reduce(joinOp)(empty);
+/** @type {(open: string) => (close: string) => (input: list.List<list.List<string>>) => list.List<string>} */
+const wrap = open => close => {
+    const seqOpen = [open];
+    const seqClose = [close];
+    return input => flat([seqOpen, join(input), seqClose]);
+};
+export const objectWrap = wrap('{')('}');
+export const arrayWrap = wrap('[')(']');
+/**
+ * @template T
+ * @typedef {O.Entry<Unknown<T>>} Entry<T>
+*/
+/**
+ * @template T
+ *  @typedef {(list.List<Entry<T>>)} Entries<T>
+*/
+/**
+ * @template T
+ * @typedef {(entries: Entries<T>) => Entries<T>} MapEntries<T>
+*/

package/out/json/serializer/test.f.mjs

@@ -0,0 +1,87 @@
+import * as _ from './module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+const { toArray } = list;
+export default {
+    arrayWrap: [
+        () => {
+            const result = JSON.stringify(toArray(_.arrayWrap(null)));
+            if (result !== '["[","]"]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = JSON.stringify(toArray(_.arrayWrap([['a', 'b']])));
+            if (result !== '["[","a","b","]"]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = JSON.stringify(toArray(_.arrayWrap([['a'], ['b']])));
+            if (result !== '["[","a",",","b","]"]') {
+                throw result;
+            }
+        }
+    ],
+    objectWrap: [
+        () => {
+            const result = JSON.stringify(toArray(_.objectWrap(null)));
+            if (result !== '["{","}"]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = JSON.stringify(toArray(_.objectWrap([['a', 'b']])));
+            if (result !== '["{","a","b","}"]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = JSON.stringify(toArray(_.objectWrap([['a'], ['b']])));
+            if (result !== '["{","a",",","b","}"]') {
+                throw result;
+            }
+        }
+    ],
+    stringSerialize: [
+        () => {
+            const result = JSON.stringify(toArray(_.stringSerialize('abc')));
+            if (result !== '["\\"abc\\""]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = JSON.stringify(toArray(_.stringSerialize('123')));
+            if (result !== '["\\"123\\""]') {
+                throw result;
+            }
+        }
+    ],
+    numberSerialize: [
+        () => {
+            const result = JSON.stringify(toArray(_.numberSerialize(123)));
+            if (result !== '["123"]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = JSON.stringify(toArray(_.numberSerialize(10e20)));
+            if (result !== '["1e+21"]') {
+                throw result;
+            }
+        }
+    ],
+    boolSerialize: [
+        () => {
+            const result = JSON.stringify(toArray(_.boolSerialize(false)));
+            if (result !== '["false"]') {
+                throw result;
+            }
+        },
+        () => {
+            const result = JSON.stringify(toArray(_.boolSerialize(true)));
+            if (result !== '["true"]') {
+                throw result;
+            }
+        }
+    ]
+};

package/out/json/test.f.mjs

@@ -0,0 +1,61 @@
+import * as json from './module.f.mjs';
+import * as o from '../types/object/module.f.mjs';
+const { sort } = o;
+import * as f from '../types/function/module.f.mjs';
+const { identity } = f;
+export default {
+    setProperty: () => {
+        if (json.setProperty("Hello")([])({}) !== "Hello") {
+            throw 'error';
+        }
+    },
+    stringify: [
+        {
+            sort: () => {
+                const r = json.setProperty("Hello")(['a'])({});
+                const x = json.stringify(sort)(r);
+                if (x !== '{"a":"Hello"}') {
+                    throw x;
+                }
+            },
+            identity: () => {
+                const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({}));
+                if (x !== '{"a":"Hello"}') {
+                    throw x;
+                }
+            },
+        },
+        {
+            sort: () => {
+                const x = json.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                if (x !== '{"a":"Hello","b":12,"c":[]}') {
+                    throw x;
+                }
+            },
+            identity: () => {
+                const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                if (x !== '{"c":[],"b":12,"a":"Hello"}') {
+                    throw x;
+                }
+            },
+        },
+        {
+            sort: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 };
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
+                const _2 = json.stringify(sort)(_1);
+                if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
+                    throw _2;
+                }
+            },
+            identity: () => {
+                const _0 = { a: { y: [24] }, c: [], b: 12 };
+                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
+                const _2 = json.stringify(identity)(_1);
+                if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
+                    throw _2;
+                }
+            }
+        }
+    ]
+};

package/out/json/tokenizer/module.f.d.mts

@@ -0,0 +1,13 @@
+/** @type {(input: list.List<number>) => list.List<JsonToken>} */
+export const tokenize: (input: list.List<number>) => list.List<JsonToken>;
+export type JsonToken = {
+    readonly kind: "true" | "false" | "null";
+} | {
+    readonly kind: "{" | "}" | ":" | "," | "[" | "]";
+} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken;
+export type ScanState = {
+    readonly kind: "def" | "-";
+};
+export type ScanInput = jsTokenizer.JsToken | null;
+import * as list from '../../types/list/module.f.mjs';
+import * as jsTokenizer from '../../js/tokenizer/module.f.mjs';

package/out/json/tokenizer/module.f.mjs

@@ -0,0 +1,78 @@
+// @ts-self-types="./module.f.d.mts"
+import * as Operator from '../../types/function/operator/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+const { empty, flat, stateScan } = list;
+import * as bf from '../../types/bigfloat/module.f.mjs';
+const { multiply } = bf;
+import * as jsTokenizer from '../../js/tokenizer/module.f.mjs';
+/**
+ * @typedef {|
+* {readonly kind: 'true' | 'false' | 'null' } |
+* {readonly kind: '{' | '}' | ':' | ',' | '[' | ']' } |
+* jsTokenizer.StringToken |
+* jsTokenizer.NumberToken |
+* jsTokenizer.ErrorToken
+* } JsonToken
+*/
+/**
+ * @typedef {|
+* {readonly kind: 'def' | '-' }
+* } ScanState
+*/
+/**
+ * @typedef {|
+* jsTokenizer.JsToken | null
+* } ScanInput
+*/
+/** @type {(input: jsTokenizer.JsToken) => list.List<JsonToken>} */
+const mapToken = input => {
+    switch (input.kind) {
+        case '{':
+        case '}':
+        case ':':
+        case ',':
+        case '[':
+        case ']':
+        case 'true':
+        case 'false':
+        case 'null':
+        case 'string':
+        case 'number':
+        case 'error': return [input];
+        case 'ws':
+        case 'nl': return empty;
+        default: return [{ kind: 'error', message: 'invalid token' }];
+    }
+};
+/** @type {(input: ScanInput) => readonly [list.List<JsonToken>, ScanState]} */
+const parseDefaultState = input => {
+    if (input === null)
+        return [empty, { kind: 'def' }];
+    switch (input.kind) {
+        case '-': return [empty, { kind: '-' }];
+        default: return [mapToken(input), { kind: 'def' }];
+    }
+};
+/** @type {(input: ScanInput) => readonly [list.List<JsonToken>, ScanState]} */
+const parseMinusState = input => {
+    if (input === null)
+        return [[{ kind: 'error', message: 'invalid token' }], { kind: 'def' }];
+    switch (input.kind) {
+        case '-': return [[{ kind: 'error', message: 'invalid token' }], { kind: '-' }];
+        case 'number': return [[{ kind: 'number', bf: multiply(input.bf)(-1n), value: `-${input.value}` }], { kind: 'def' }];
+        default: return [{ first: { kind: 'error', message: 'invalid token' }, tail: mapToken(input) }, { kind: 'def' }];
+    }
+};
+/** @type {Operator.StateScan<ScanInput, ScanState, list.List<JsonToken>>} */
+const scanToken = state => input => {
+    switch (state.kind) {
+        case '-': return parseMinusState(input);
+        default: return parseDefaultState(input);
+    }
+};
+/** @type {(input: list.List<number>) => list.List<JsonToken>} */
+export const tokenize = input => {
+    /** @type {list.List<ScanInput>} */
+    const jsTokens = jsTokenizer.tokenize(input);
+    return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])));
+};