functionalscript 0.1.609 → 0.2.1

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

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

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/{json → out/json}/parser/module.f.d.mts

@@ -1,18 +1,16 @@
-declare namespace _default {
-    export { parse };
-}
-export default _default;
+/** @type {(tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>} */
+export const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;
 export type JsonObject = {
     readonly kind: "object";
-    readonly values: Map.Map<Json.Unknown>;
+    readonly values: map.Map<Json.Unknown>;
     readonly key: string;
 };
 export type JsonArray = {
     readonly kind: "array";
-    readonly values: List.List<Json.Unknown>;
+    readonly values: list.List<Json.Unknown>;
 };
 export type JsonStackElement = JsonObject | JsonArray;
-export type JsonStack = List.List<JsonStackElement>;
+export type JsonStack = list.List<JsonStackElement>;
 export type StateParse = {
     readonly status: "" | "[" | "[v" | "[," | "{" | "{k" | "{:" | "{v" | "{,";
     readonly top: JsonStackElement | null;
@@ -27,10 +25,8 @@ export type StateError = {
     readonly message: string;
 };
 export type JsonState = StateParse | StateResult | StateError;
-/** @type {(tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>} */
-declare const parse: (tokenList: List.List<Tokenizer.JsonToken>) => Result.Result<Json.Unknown, string>;
-import * as Map from '../../types/map/module.f.mjs';
-import * as Json from '../module.f.mjs';
-import * as List from '../../types/list/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
 import * as Tokenizer from '../tokenizer/module.f.mjs';
-import * as Result from '../../types/result/module.f.mjs';
+import * as result from '../../types/result/module.f.mjs';
+import * as Json from '../module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';

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