functionalscript 0.2.0 → 0.2.2

package/out/json/module.f.mjs

@@ -0,0 +1,89 @@
+// @ts-self-types="./module.f.d.mts"
+import * as list from '../types/list/module.f.mjs';
+const { next, flat, map } = list;
+import * as string from '../types/string/module.f.mjs';
+const { concat } = string;
+import * as object from '../types/object/module.f.mjs';
+const { at } = object;
+import * as f from '../types/function/module.f.mjs';
+const { compose, fn } = f;
+const { entries } = Object;
+import * as s from './serializer/module.f.mjs';
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = s;
+/**
+ * @typedef {{
+ *  readonly [k in string]: Unknown
+ * }} Object
+ */
+/** @typedef {readonly Unknown[]} Array */
+/** @typedef {Object|boolean|string|number|null|Array} Unknown */
+/** @type {(value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown} */
+export const setProperty = value => {
+    /** @type {(path: list.List<string>) => (src: Unknown) => Unknown} */
+    const f = path => src => {
+        const result = next(path);
+        if (result === null) {
+            return value;
+        }
+        const srcObject = (src === null || typeof src !== 'object' || src instanceof Array) ? {} : src;
+        const { first, tail } = result;
+        return { ...srcObject, [first]: f(tail)(at(first)(srcObject)) };
+    };
+    return f;
+};
+const colon = [':'];
+/** @typedef {object.Entry<Unknown>} Entry*/
+/** @typedef {(list.List<Entry>)} Entries */
+/** @typedef {(entries: Entries) => Entries} MapEntries */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => list.List<string>} */
+export const serialize = sort => {
+    /** @type {(kv: readonly[string, Unknown]) => list.List<string>} */
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ]);
+    const mapPropertySerialize = map(propertySerialize);
+    /** @type {(object: Object) => list.List<string>} */
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result;
+    /** @type {(value: Unknown) => list.List<string>} */
+    const f = value => {
+        switch (typeof value) {
+            case 'boolean': {
+                return boolSerialize(value);
+            }
+            case 'number': {
+                return numberSerialize(value);
+            }
+            case 'string': {
+                return stringSerialize(value);
+            }
+            default: {
+                if (value === null) {
+                    return nullSerialize;
+                }
+                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
+ *
+ * @type {(mapEntries: MapEntries) => (value: Unknown) => string}
+ */
+export const stringify = sort => compose(serialize(sort))(concat);
+/** @type {(value: string) => Unknown} */
+export const parse = JSON.parse;
+/** @type {(value: Unknown) => value is Object} */
+export const isObject = value => typeof value === 'object' && value !== null && !(value instanceof Array);

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

@@ -0,0 +1,224 @@
+// @ts-self-types="./module.f.d.mts"
+import * as result from '../../types/result/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+const { fold, first, drop, toArray } = list;
+import * as Operator from '../../types/function/operator/module.f.mjs';
+import * as Tokenizer from '../tokenizer/module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';
+const { setReplace } = map;
+import * as Json from '../module.f.mjs';
+import * as o from '../../types/object/module.f.mjs';
+const { fromMap } = o;
+/**
+ * @typedef {{
+* readonly kind: 'object'
+* readonly values: map.Map<Json.Unknown>
+* readonly key: string
+* }} JsonObject
+* */
+/**
+ * @typedef {{
+* readonly kind: 'array'
+* readonly values: list.List<Json.Unknown>
+* }} JsonArray
+* */
+/**
+ * @typedef {|
+* JsonObject |
+* JsonArray
+* } JsonStackElement
+*/
+/** @typedef {list.List<JsonStackElement>} JsonStack */
+/**
+ * @typedef {{
+*  readonly status: '' | '[' | '[v' | '[,' | '{' | '{k' | '{:' | '{v' | '{,'
+*  readonly top: JsonStackElement | null
+*  readonly stack: JsonStack
+* }} StateParse
+*/
+/**
+ * @typedef {{
+*  readonly status: 'result'
+*  readonly value: Json.Unknown
+* }} StateResult
+*/
+/**
+ * @typedef {{
+*  readonly status: 'error'
+*  readonly message: string
+* }} StateError
+*/
+/**
+ * @typedef {|
+* StateParse |
+* StateResult |
+* StateError
+* } JsonState
+*/
+/** @type {(obj: JsonObject) => (key: string) => JsonObject} */
+const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });
+/** @type {(obj: JsonObject) => (value: Json.Unknown) => JsonObject} */
+const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' });
+/** @type {(array: JsonArray) => (value: Json.Unknown) => JsonArray} */
+const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) });
+/** @type {(state: StateParse) => (key: string) => JsonState} */
+const pushKey = state => value => {
+    if (state.top?.kind === 'object') {
+        return { status: '{k', top: addKeyToObject(state.top)(value), stack: state.stack };
+    }
+    return { status: 'error', message: 'error' };
+};
+/** @type {(state: StateParse) => (value: Json.Unknown) => JsonState} */
+const pushValue = state => value => {
+    if (state.top === null) {
+        return { status: 'result', value: value };
+    }
+    if (state.top.kind === 'array') {
+        return { status: '[v', top: addToArray(state.top)(value), stack: state.stack };
+    }
+    return { status: '{v', top: addValueToObject(state.top)(value), stack: state.stack };
+};
+/** @type {(state: StateParse) => JsonState} */
+const startArray = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
+    return { status: '[', top: { kind: 'array', values: null }, stack: newStack };
+};
+/** @type {(state: StateParse) => JsonState} */
+const endArray = state => {
+    const array = state.top !== null ? toArray(state.top.values) : null;
+    /** @type {StateParse} */
+    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    return pushValue(newState)(array);
+};
+/** @type {(state: StateParse) => JsonState} */
+const startObject = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
+    return { status: '{', top: { kind: 'object', values: null, key: '' }, stack: newStack };
+};
+/** @type {(state: StateParse) => JsonState} */
+const endObject = state => {
+    const obj = state.top?.kind === 'object' ? fromMap(state.top.values) : null;
+    /** @type {StateParse} */
+    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    return pushValue(newState)(obj);
+};
+/** @type {(token: Tokenizer.JsonToken) => Json.Unknown} */
+const tokenToValue = token => {
+    switch (token.kind) {
+        case 'null': return null;
+        case 'false': return false;
+        case 'true': return true;
+        case 'number': return parseFloat(token.value);
+        case 'string': return token.value;
+        default: return null;
+    }
+};
+/** @type {(token: Tokenizer.JsonToken) => boolean} */
+const isValueToken = token => {
+    switch (token.kind) {
+        case 'null':
+        case 'false':
+        case 'true':
+        case 'number':
+        case 'string': return true;
+        default: return false;
+    }
+};
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseValueOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    if (token.kind === '[') {
+        return startArray(state);
+    }
+    if (token.kind === '{') {
+        return startObject(state);
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseArrayStartOp = token => state => {
+    if (isValueToken(token)) {
+        return pushValue(state)(tokenToValue(token));
+    }
+    if (token.kind === '[') {
+        return startArray(state);
+    }
+    if (token.kind === ']') {
+        return endArray(state);
+    }
+    if (token.kind === '{') {
+        return startObject(state);
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseArrayValueOp = token => state => {
+    if (token.kind === ']') {
+        return endArray(state);
+    }
+    if (token.kind === ',') {
+        return { status: '[,', top: state.top, stack: state.stack };
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseObjectStartOp = token => state => {
+    if (token.kind === 'string') {
+        return pushKey(state)(token.value);
+    }
+    if (token.kind === '}') {
+        return endObject(state);
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseObjectKeyOp = token => state => {
+    if (token.kind === ':') {
+        return { status: '{:', top: state.top, stack: state.stack };
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseObjectNextOp = token => state => {
+    if (token.kind === '}') {
+        return endObject(state);
+    }
+    if (token.kind === ',') {
+        return { status: '{,', top: state.top, stack: state.stack };
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+/** @type {(token: Tokenizer.JsonToken) => (state: StateParse) => JsonState}} */
+const parseObjectCommaOp = token => state => {
+    if (token.kind === 'string') {
+        return pushKey(state)(token.value);
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+/** @type {Operator.Fold<Tokenizer.JsonToken, JsonState>} */
+const foldOp = token => state => {
+    switch (state.status) {
+        case 'result': return { status: 'error', message: 'unexpected token' };
+        case 'error': return { status: 'error', message: state.message };
+        case '': return parseValueOp(token)(state);
+        case '[': return parseArrayStartOp(token)(state);
+        case '[v': return parseArrayValueOp(token)(state);
+        case '[,': return parseValueOp(token)(state);
+        case '{': return parseObjectStartOp(token)(state);
+        case '{k': return parseObjectKeyOp(token)(state);
+        case '{:': return parseValueOp(token)(state);
+        case '{v': return parseObjectNextOp(token)(state);
+        case '{,': return parseObjectCommaOp(token)(state);
+    }
+};
+/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
+export const parse = tokenList => {
+    const state = fold(foldOp)({ status: '', top: null, stack: null })(tokenList);
+    switch (state.status) {
+        case 'result': return result.ok(state.value);
+        case 'error': return result.error(state.message);
+        default: return result.error('unexpected end');
+    }
+};

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