functionalscript 0.4.3 → 0.4.4

package/djs/ast/test.f.js

@@ -0,0 +1,41 @@
+import * as list from "../../types/object/module.f.js";
+const { sort } = list;
+import * as shared from "./module.f.js";
+import { stringify } from "../serializer/module.f.js";
+export default {
+    test: () => {
+        const djs = shared.run([1])([]);
+        const result = stringify(sort)(djs);
+        if (result !== '1') {
+            throw result;
+        }
+    },
+    testCref: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '4') {
+            throw result;
+        }
+    },
+    testAref: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '14') {
+            throw result;
+        }
+    },
+    testArray: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '[14,4]') {
+            throw result;
+        }
+    },
+    testObj: () => {
+        const djs = shared.run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);
+        const result = stringify(sort)(djs);
+        if (result !== '{"key":{"key2":[14,4]}}') {
+            throw result;
+        }
+    },
+};

package/djs/module.f.d.ts

@@ -1,17 +1,7 @@
-import * as list from '../types/list/module.f.ts';
-import type * as O from '../types/object/module.f.ts';
-type Object = {
+import type { Primitive as JsonPrimitive } from '../json/module.f.ts';
+export type Object = {
     readonly [k in string]: Unknown;
 };
-type Array = readonly Unknown[];
-type Unknown = Object | boolean | string | number | null | Array | bigint | undefined;
-type Entry = O.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 {};
+export type Array = readonly Unknown[];
+export type Primitive = JsonPrimitive | bigint | undefined;
+export type Unknown = Primitive | Object | Array;

package/djs/module.f.js

@@ -1,62 +1 @@
-import * as list from "../types/list/module.f.js";
-const { flat, map } = list;
-import * as string from "../types/string/module.f.js";
-const { concat } = string;
-import * as f from "../types/function/module.f.js";
-const { compose, fn } = f;
-const { entries } = Object;
-import * as bi from "../types/bigint/module.f.js";
-const { serialize: bigintSerialize } = bi;
-import * as j from "../json/serializer/module.f.js";
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
-import * as djs from "./serializer/module.f.js";
-const { undefinedSerialize } = djs;
-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);
-            }
-            case 'bigint': {
-                return [bigintSerialize(value)];
-            }
-            default: {
-                if (value === null) {
-                    return nullSerialize;
-                }
-                if (value === undefined) {
-                    return undefinedSerialize;
-                }
-                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 {};

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

@@ -1,12 +1,12 @@
 import * as result from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
-import type * as tokenizerT from '../tokenizer/module.f.ts';
-export type DjsModule = [readonly string[], readonly DjsConst[]];
-export type DjsConst = boolean | string | number | null | bigint | undefined | DjsModuleRef | DjsArray | DjsObject;
-type DjsModuleRef = ['aref' | 'cref', number];
-type DjsArray = ['array', readonly DjsConst[]];
-export type DjsObject = {
-    readonly [k in string]: DjsConst;
+import type { DjsToken } from '../tokenizer/module.f.ts';
+import { type Map } from '../../types/map/module.f.ts';
+import type { Fs } from '../../io/module.f.ts';
+import type { AstModule } from '../ast/module.f.ts';
+export type ParseContext = {
+    readonly fs: Fs;
+    readonly complete: Map<result.Result<AstModule, string>>;
+    readonly stack: List<string>;
 };
-export declare const parse: (tokenList: List<tokenizerT.DjsToken>) => result.Result<DjsModule, string>;
-export {};
+export declare const parseFromTokens: (tokenList: List<DjsToken>) => result.Result<AstModule, string>;

package/djs/parser/module.f.js

@@ -1,8 +1,7 @@
 import * as result from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
 import { setReplace, at } from "../../types/map/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { fromMap } = o;
+import { fromMap } from "../../types/object/module.f.js";
 const parseInitialOp = token => state => {
     switch (token.kind) {
         case 'ws':
@@ -59,8 +58,8 @@ const parseConstOp = token => state => {
         case 'id': {
             if (at(token.value)(state.module.refs) !== null)
                 return { state: 'error', message: 'duplicate id' };
-            let cref = ['cref', length(state.module.consts)];
-            let refs = setReplace(token.value)(cref)(state.module.refs);
+            const cref = ['cref', length(state.module.consts)];
+            const refs = setReplace(token.value)(cref)(state.module.refs);
             return { ...state, state: 'const+name', module: { ...state.module, refs: refs } };
         }
         default: return { state: 'error', message: 'unexpected token' };
@@ -86,8 +85,8 @@ const parseImportOp = token => state => {
             if (at(token.value)(state.module.refs) !== null) {
                 return { state: 'error', message: 'duplicate id' };
             }
-            let aref = ['aref', length(state.module.modules)];
-            let refs = setReplace(token.value)(aref)(state.module.refs);
+            const aref = ['aref', length(state.module.modules)];
+            const refs = setReplace(token.value)(aref)(state.module.refs);
             return { ...state, state: 'import+name', module: { ...state.module, refs: refs } };
         }
         default: return { state: 'error', message: 'unexpected token' };
@@ -130,7 +129,7 @@ const pushKey = state => key => {
 };
 const pushValue = state => value => {
     if (state.top === null) {
-        let consts = concat(state.module.consts)([value]);
+        const consts = concat(state.module.consts)([value]);
         switch (state.state) {
             case 'exportValue': return { ...state, state: 'result', module: { ...state.module, consts: consts } };
             case 'constValue': return { ...state, state: 'nl', module: { ...state.module, consts: consts } };
@@ -321,7 +320,7 @@ const foldOp = token => state => {
             }
     }
 };
-export const parse = (tokenList) => {
+export const parseFromTokens = (tokenList) => {
     const state = fold(foldOp)({ state: '', module: { refs: null, modules: null, consts: null } })(tokenList);
     switch (state.state) {
         case 'result': return result.ok([toArray(state.module.modules), toArray(state.module.consts)]);