functionalscript 0.3.4 → 0.3.6

package/json/module.f.d.ts

@@ -0,0 +1,20 @@
+import * as list from '../types/list/module.f.ts';
+import * as object from '../types/object/module.f.ts';
+type Object = {
+    readonly [k in string]: Unknown;
+};
+type Array = readonly Unknown[];
+export type Unknown = Object | boolean | string | number | null | Array;
+export declare const setProperty: (value: Unknown) => (path: list.List<string>) => (src: Unknown) => Unknown;
+export type Entry = object.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 declare const parse: (value: string) => Unknown;
+export declare const isObject: (value: Unknown) => value is Object;
+export {};

package/json/module.f.js

@@ -0,0 +1,68 @@
+import * as list from "../types/list/module.f.js";
+const { next, flat, map } = list;
+import * as string from "../types/string/module.f.js";
+const { concat } = string;
+import * as object from "../types/object/module.f.js";
+const { at } = object;
+import * as f from "../types/function/module.f.js";
+const { compose, fn } = f;
+const { entries } = Object;
+import * as s from "./serializer/module.f.js";
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = s;
+export const setProperty = value => {
+    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 = [':'];
+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);
+            }
+            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
+ */
+export const stringify = sort => compose(serialize(sort))(concat);
+export const parse = JSON.parse;
+export const isObject = (value) => typeof value === 'object' && value !== null && !(value instanceof Array);

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

@@ -0,0 +1,5 @@
+import * as result from '../../types/result/module.f.ts';
+import * as list from '../../types/list/module.f.ts';
+import * as Tokenizer from '../tokenizer/module.f.ts';
+import * as Json from '../module.f.ts';
+export declare const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;

package/json/parser/module.f.js

@@ -0,0 +1,155 @@
+import * as result from "../../types/result/module.f.js";
+import * as list from "../../types/list/module.f.js";
+const { fold, first, drop, toArray } = list;
+import * as Operator from "../../types/function/operator/module.f.js";
+import * as Tokenizer from "../tokenizer/module.f.js";
+import * as map from "../../types/map/module.f.js";
+const { setReplace } = map;
+import * as Json from "../module.f.js";
+import * as o from "../../types/object/module.f.js";
+const { fromMap } = o;
+const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });
+const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' });
+const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) });
+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' };
+};
+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 };
+};
+const startArray = state => {
+    const newStack = state.top === null ? null : { first: state.top, tail: state.stack };
+    return { status: '[', top: { kind: 'array', values: null }, stack: newStack };
+};
+const endArray = state => {
+    const array = state.top !== null ? toArray(state.top.values) : null;
+    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    return pushValue(newState)(array);
+};
+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 };
+};
+const endObject = state => {
+    const obj = state.top?.kind === 'object' ? fromMap(state.top.values) : null;
+    const newState = { status: '', top: first(null)(state.stack), stack: drop(1)(state.stack) };
+    return pushValue(newState)(obj);
+};
+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;
+    }
+};
+const isValueToken = token => {
+    switch (token.kind) {
+        case 'null':
+        case 'false':
+        case 'true':
+        case 'number':
+        case 'string': return true;
+        default: return false;
+    }
+};
+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' };
+};
+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' };
+};
+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' };
+};
+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' };
+};
+const parseObjectKeyOp = token => state => {
+    if (token.kind === ':') {
+        return { status: '{:', top: state.top, stack: state.stack };
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+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' };
+};
+const parseObjectCommaOp = token => state => {
+    if (token.kind === 'string') {
+        return pushKey(state)(token.value);
+    }
+    return { status: 'error', message: 'unexpected token' };
+};
+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);
+    }
+};
+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/json/parser/test.f.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    valid: (() => void)[];
+    invalid: (() => void)[];
+};
+export default _default;

package/json/parser/test.f.js

@@ -0,0 +1,328 @@
+import * as parser from "./module.f.js";
+import * as tokenizer from "../tokenizer/module.f.js";
+import * as list from "../../types/list/module.f.js";
+const { toArray } = list;
+import * as json from "../module.f.js";
+import * as o from "../../types/object/module.f.js";
+const { sort } = o;
+import * as encoding from "../../text/utf16/module.f.js";
+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;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('undefined');
+            const obj = parser.parse(tokenList);
+            const result = stringify(obj);
+            if (result !== '["error","unexpected token"]') {
+                throw result;
+            }
+        },
+    ]
+};

package/json/serializer/module.f.d.ts

@@ -0,0 +1,7 @@
+import * as list from '../../types/list/module.f.ts';
+export declare const stringSerialize: (_: string) => list.List<string>;
+export declare const numberSerialize: (_: number) => list.List<string>;
+export declare const nullSerialize: string[];
+export declare const boolSerialize: (_: boolean) => list.List<string>;
+export declare const objectWrap: (input: list.List<list.List<string>>) => list.List<string>;
+export declare const arrayWrap: (input: list.List<list.List<string>>) => list.List<string>;

package/json/serializer/module.f.js

@@ -0,0 +1,21 @@
+import * as list from "../../types/list/module.f.js";
+const { flat, reduce, empty } = list;
+import * as O from "../../types/object/module.f.js";
+import * as Operator from "../../types/function/operator/module.f.js";
+const jsonStringify = JSON.stringify;
+export const stringSerialize = input => [jsonStringify(input)];
+export const numberSerialize = input => [jsonStringify(input)];
+export const nullSerialize = ['null'];
+const trueSerialize = ['true'];
+const falseSerialize = ['false'];
+export const boolSerialize = value => value ? trueSerialize : falseSerialize;
+const comma = [','];
+const joinOp = b => prior => flat([prior, comma, b]);
+const join = reduce(joinOp)(empty);
+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('[')(']');

package/json/serializer/test.f.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    arrayWrap: (() => void)[];
+    objectWrap: (() => void)[];
+    stringSerialize: (() => void)[];
+    numberSerialize: (() => void)[];
+    boolSerialize: (() => void)[];
+};
+export default _default;