functionalscript 0.2.0 → 0.2.2

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.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])));
+};