functionalscript 0.7.0 → 0.8.1

package/README.md

@@ -19,7 +19,7 @@ Learn more about
 - [Purely Functional Programming in JavaScript](https://blog.bitsrc.io/purely-functional-programming-in-javascript-91114b1b2dff?sk=5f7132e56902f38fcf4c6164bfa681ed),
 - [FunctionalScript and I/O](https://medium.com/@sergeyshandar/functionalscript-5cf817345376?sk=30b32189a81d1a2dad16c2244f32328d).
 
-This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributed under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
+This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributed under [MIT](LICENSE).
 
 ## Getting Started
 
@@ -75,4 +75,5 @@ In FunctionalScript:
 ## Sponsors
 
 - [KirillOsenkov](https://github.com/KirillOsenkov),
-- [antkmsft](https://github.com/antkmsft).
+- [antkmsft](https://github.com/antkmsft),
+- [Mark Heyman](https://opencollective.com/body-count).

package/bnf/data/module.f.d.ts

@@ -11,27 +11,37 @@ export type Rule = Variant | Sequence | TerminalRange;
 /** The full grammar */
 export type RuleSet = Readonly<Record<string, Rule>>;
 type EmptyTag = string | true | undefined;
+type EmptyTagEntry = string | boolean;
 type DispatchRule = {
     readonly emptyTag: EmptyTag;
     readonly rangeMap: Dispatch;
 };
 type Dispatch = RangeMapArray<DispatchResult>;
 type DispatchResult = DispatchRuleCollection | null;
+type DispatchRuleOrName = DispatchRule | string;
 type DispatchRuleCollection = {
     readonly tag: string | undefined;
-    readonly rules: DispatchRule[];
+    readonly rules: DispatchRuleOrName[];
 };
 type DispatchMap = {
     readonly [id in string]: DispatchRule;
 };
+type EmptyTagMap = {
+    readonly [id in string]: EmptyTagEntry;
+};
+export type DescentMatchRule = (r: Rule, s: readonly CodePoint[], idx: number) => MatchResult;
 /**
  * Represents a parsed Abstract Syntax Tree (AST) sequence.
  */
 export type AstSequence = readonly (AstRule | CodePoint)[];
+type AstTag = string | true | undefined;
 /**
  * Represents a parsed AST rule, consisting of a rule name and its parsed sequence.
  */
-export type AstRule = readonly [string, AstSequence];
+type AstRule = {
+    readonly tag: AstTag;
+    readonly sequence: AstSequence;
+};
 /**
  * Represents the remaining input after a match attempt, or `null` if no match is possible.
  */
@@ -39,15 +49,15 @@ export type Remainder = readonly CodePoint[] | null;
 /**
  * Represents the result of a match operation, including the parsed AST rule and the remainder of the input.
  */
-export type MatchResult = readonly [AstRule, Remainder];
+export type MatchResult = readonly [AstRule, boolean, Remainder];
 /**
  * Represents an LL(1) parser function for matching input against grammar rules.
  */
 export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
+export type MatchRule = (dr: DispatchRule, s: readonly CodePoint[]) => MatchResult;
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
 export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
+export declare const createEmptyTagMap: (data: readonly [RuleSet, string]) => EmptyTagMap;
 export declare const parser: (fr: FRule) => Match;
+export declare const parserRuleSet: (ruleSet: RuleSet) => Match;
 export {};
-/**
- * Either `{ variantItem: id }` or `id`.
- */

package/bnf/data/module.f.js

@@ -1,8 +1,8 @@
-import { todo } from "../../dev/module.f.js";
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
 import { strictEqual } from "../../types/function/operator/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
 import { rangeMap } from "../../types/range_map/module.f.js";
+import { contains, set } from "../../types/string_set/module.f.js";
 import { oneEncode, rangeDecode, } from "../module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
@@ -91,20 +91,21 @@ const dispatchOp = rangeMap({
     def: null,
 });
 export const dispatchMap = (ruleSet) => {
-    const addRuleToDispatch = (dr, rule) => {
+    const addRuleToDispatch = (dr, name) => {
         if (dr === null)
             return null;
-        return { tag: dr.tag, rules: [...dr.rules, rule] };
+        return { tag: dr.tag, rules: [...dr.rules, name] };
     };
     const addTagToDispatch = (dr, tag) => {
         if (dr === null)
             return null;
         return { tag, rules: dr.rules };
     };
-    const dispatchRule = (dm, name) => {
+    const dispatchRule = (dm, name, current) => {
         if (name in dm) {
             return dm;
         }
+        const newCurrent = set(name)(current);
         const rule = ruleSet[name];
         if (typeof rule === 'number') {
             const range = rangeDecode(rule);
@@ -116,14 +117,20 @@ export const dispatchMap = (ruleSet) => {
             let emptyTag = true;
             let result = [];
             for (const item of rule) {
-                dm = dispatchRule(dm, item);
-                const dr = dm[item];
-                if (emptyTag === true) {
-                    result = toArray(dispatchOp.merge(result)(dr.rangeMap));
-                    emptyTag = dr.emptyTag !== undefined ? true : undefined;
+                if (contains(item)(newCurrent)) {
+                    result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
                 }
                 else {
-                    result = result.map(x => [addRuleToDispatch(x[0], dr), x[1]]);
+                    dm = dispatchRule(dm, item, newCurrent);
+                    const dr = dm[item];
+                    if (emptyTag === true) {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
+                        result = toArray(dispatchOp.merge(result)(dr.rangeMap));
+                        emptyTag = dr.emptyTag !== undefined ? true : undefined;
+                    }
+                    else {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
+                    }
                 }
             }
             const dr = { emptyTag, rangeMap: result };
@@ -134,7 +141,7 @@ export const dispatchMap = (ruleSet) => {
             let result = [];
             let emptyTag = undefined;
             for (const [tag, item] of entries) {
-                dm = dispatchRule(dm, item);
+                dm = dispatchRule(dm, item, newCurrent);
                 const dr = dm[item];
                 if (dr.emptyTag !== undefined) {
                     emptyTag = tag;
@@ -150,21 +157,106 @@ export const dispatchMap = (ruleSet) => {
     };
     let result = {};
     for (const k in ruleSet) {
-        result = dispatchRule(result, k);
+        result = dispatchRule(result, k, null);
     }
     return result;
 };
+const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
+    if (name in map) {
+        return [ruleSet, map, map[name]];
+    }
+    const rule = ruleSet[name];
+    if (typeof rule === 'number') {
+        return [ruleSet, { ...map, [name]: false }, false];
+    }
+    else if (rule instanceof Array) {
+        map = { ...map, [name]: true };
+        let emptyTag = rule.length == 0;
+        for (const item of rule) {
+            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
+            map = newMap;
+            if (emptyTag === false) {
+                emptyTag = itemEmptyTag !== false;
+            }
+        }
+        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
+    }
+    else {
+        map = { ...map, [name]: true };
+        const entries = Object.entries(rule);
+        let emptyTag = false;
+        for (const [tag, item] of entries) {
+            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
+            map = newMap;
+            if (itemEmptyTag !== false) {
+                emptyTag = tag;
+            }
+        }
+        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
+    }
+};
+export const createEmptyTagMap = (data) => {
+    return emptyTagMapAdd(data[0])({})(data[1])[1];
+};
+// export const parserDescent = (fr: FRule): Match => {
+//     const data = toData(fr)
+//     const getEmptyTag = (rule: Rule): EmptyTag => {
+//         return todo()
+//     }
+//     const f: DescentMatchRule = (r, cp, idx): MatchResult => {
+//         const mrSuccess = (tag: AstTag, sequence: AstSequence, r: Remainder): MatchResult => [{tag, sequence}, true, r]
+//         const mrFail = (tag: AstTag, sequence: AstSequence, r: Remainder): MatchResult => [{tag, sequence}, false, r]
+//         if (idx >= cp.length) {
+//             const emptyTag = getEmptyTag(r)
+//             return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp)
+//         }
+//         return todo()
+//     }
+//     const match: Match = (name, cp): MatchResult => {
+//         return f(data[0][name], cp, 0)
+//     }
+//     return match
+// }
 export const parser = (fr) => {
     const data = toData(fr);
-    return todo();
+    return parserRuleSet(data[0]);
+};
+export const parserRuleSet = (ruleSet) => {
+    const map = dispatchMap(ruleSet);
+    const f = (rule, cp) => {
+        const mrSuccess = (tag, sequence, r) => [{ tag, sequence }, true, r];
+        const mrFail = (tag, sequence, r) => [{ tag, sequence }, false, r];
+        const { emptyTag, rangeMap } = rule;
+        if (cp.length === 0) {
+            return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp);
+        }
+        const cp0 = cp[0];
+        const dr = dispatchOp.get(cp0)(rangeMap);
+        if (dr === null) {
+            if (emptyTag === undefined) {
+                return mrFail(emptyTag, [], cp);
+            }
+            return mrSuccess(emptyTag, [], cp);
+        }
+        let seq = [cp0];
+        let r = cp;
+        const [_, ...restCp] = cp;
+        r = restCp;
+        const { tag, rules } = dr;
+        for (const i of rules) {
+            const rule = typeof i === 'string' ? map[i] : i;
+            const res = f(rule, r);
+            const [astRule, success, newR] = res;
+            if (success === false) {
+                return res;
+            }
+            seq = [...seq, astRule];
+            if (newR === null) {
+                return mrSuccess(tag, seq, null);
+            }
+            r = newR;
+        }
+        return mrSuccess(tag, seq, r);
+    };
+    return (name, cp) => f(map[name], cp);
 };
-/**
- * Either `{ variantItem: id }` or `id`.
- */
-/*
-type DispatchRule = SingleProperty<> | string
-
-type Dispatch = RangeMapArray<DispatchRule>
-
-type DispatchMap = { readonly[id in string]: Dispatch }
-*/

package/bnf/data/test.f.d.ts

@@ -1,7 +1,11 @@
 declare const _default: {
     toData: (() => void)[];
+    emptyTags: (() => void)[];
     variantTest: () => void;
     dispatch: (() => void)[];
+    parser: (() => void)[];
+    repeat: (() => void)[];
+    repeatParser: (() => void)[];
     example: () => void;
 };
 export default _default;