@thi.ng/parse 2.4.51 → 2.4.52

package/CHANGELOG.md

@@ -1,6 +1,6 @@
 # Change Log
 
-- **Last updated**: 2024-08-18T14:11:34Z
+- **Last updated**: 2024-08-29T12:31:25Z
 - **Generator**: [thi.ng/monopub](https://thi.ng/monopub)
 
 All notable changes to this project will be documented in this file.
@@ -9,6 +9,15 @@ See [Conventional Commits](https://conventionalcommits.org/) for commit guidelin
 **Note:** Unlisted _patch_ versions only involve non-code or otherwise excluded changes
 and/or version bumps of transitive dependencies.
 
+### [2.4.52](https://github.com/thi-ng/umbrella/tree/@thi.ng/parse@2.4.52) (2024-08-29)
+
+#### ⏱ Performance improvements
+
+- update ParseState & ParseScope handling (result: 1.2-1.6x faster) ([c94b5cf](https://github.com/thi-ng/umbrella/commit/c94b5cf))
+  - refactor ParseState/Scope as data classes (keep same structure)
+  - minor update scope transforms
+  - update tests
+
 ### [2.4.43](https://github.com/thi-ng/umbrella/tree/@thi.ng/parse@2.4.43) (2024-06-21)
 
 #### ♻️ Refactoring

package/api.d.ts

@@ -1,18 +1,5 @@
 import type { Fn, Fn0, IObjectOf, Nullable } from "@thi.ng/api";
-import type { ParseContext } from "./context.js";
-export interface ParseScope<T> {
-    id: string;
-    state: Nullable<ParseState<T>>;
-    children: Nullable<ParseScope<T>[]>;
-    result: any;
-}
-export interface ParseState<T> {
-    p: number;
-    l: number;
-    c: number;
-    done?: boolean;
-    last?: T;
-}
+import type { ParseContext, ParseScope, ParseState } from "./context.js";
 export interface IReader<T> {
     read(state: ParseState<T>): T;
     next(state: ParseState<T>): void;

package/combinators/check.d.ts

@@ -1,4 +1,5 @@
 import type { Predicate } from "@thi.ng/api";
-import type { Parser, ParseScope } from "../api.js";
+import type { Parser } from "../api.js";
+import type { ParseScope } from "../context.js";
 export declare const check: <T>(parser: Parser<T>, pred: Predicate<ParseScope<T>>, msg?: string) => Parser<T>;
 //# sourceMappingURL=check.d.ts.map

package/combinators/lookahead.js

@@ -3,7 +3,7 @@ const lookahead = (parser, ahead, capture = false, id = "lookahead") => (ctx) =>
   ctx.start(id);
   let pass = false;
   while (true) {
-    const state = capture ? null : { ...ctx.state };
+    const state = capture ? null : ctx.state.copy();
     if (ahead(ctx)) {
       !capture && (ctx.state = state);
       return pass ? ctx.end() : ctx.discard();

package/context.d.ts

@@ -1,4 +1,22 @@
-import type { ContextOpts, IReader, ParseScope, ParseState } from "./api.js";
+import type { ICopy, Nullable } from "@thi.ng/api";
+import type { ContextOpts, IReader } from "./api.js";
+export declare class ParseState<T> implements ICopy<ParseState<T>> {
+    p: number;
+    l: number;
+    c: number;
+    done?: boolean | undefined;
+    last?: T | undefined;
+    constructor(p: number, l: number, c: number, done?: boolean | undefined, last?: T | undefined);
+    copy(): ParseState<T>;
+}
+export declare class ParseScope<T> implements ICopy<ParseScope<T>> {
+    id: string;
+    state?: Nullable<ParseState<T>>;
+    children?: Nullable<ParseScope<T>[]>;
+    result?: any;
+    constructor(id: string, state?: Nullable<ParseState<T>>, children?: Nullable<ParseScope<T>[]>, result?: any);
+    copy(): ParseScope<T>;
+}
 export declare class ParseContext<T> {
     reader: IReader<T>;
     opts: ContextOpts;
@@ -29,7 +47,7 @@ export declare class ParseContext<T> {
     /**
      * Returns root node's children or `undefined`.
      */
-    get children(): import("@thi.ng/api").Nullable<ParseScope<T>[]>;
+    get children(): Nullable<ParseScope<T>[]>;
     /**
      * Returns max. recursion depth which was actually reached. Will always be
      * less or equal configured {@link ContextOpts.maxDepth}.

package/context.js

@@ -4,6 +4,34 @@ import { parseError } from "./error.js";
 import { defArrayReader } from "./readers/array-reader.js";
 import { defStringReader } from "./readers/string-reader.js";
 import { __indent } from "./utils.js";
+class ParseState {
+  constructor(p, l, c, done, last) {
+    this.p = p;
+    this.l = l;
+    this.c = c;
+    this.done = done;
+    this.last = last;
+  }
+  copy() {
+    return new ParseState(this.p, this.l, this.c, this.done, this.last);
+  }
+}
+class ParseScope {
+  constructor(id, state, children, result) {
+    this.id = id;
+    this.state = state;
+    this.children = children;
+    this.result = result;
+  }
+  copy() {
+    return new ParseScope(
+      this.id,
+      this.state,
+      this.children,
+      this.result
+    );
+  }
+}
 class ParseContext {
   constructor(reader, opts) {
     this.reader = reader;
@@ -21,28 +49,21 @@ class ParseContext {
   _debug;
   _retain;
   reset() {
-    this._curr = {
-      id: "root",
-      state: { p: 0, l: 1, c: 1 },
-      children: null,
-      result: null
-    };
+    this._curr = new ParseScope("root", new ParseState(0, 1, 1));
     this._scopes = [this._curr];
     this._peakDepth = 1;
     this.reader.isDone(this._curr.state);
     return this;
   }
   start(id) {
-    if (this._scopes.length >= this._maxDepth) {
-      parseError(this, `recursion limit reached ${this._maxDepth}`);
+    const { _scopes: scopes, _maxDepth } = this;
+    if (scopes.length >= _maxDepth) {
+      parseError(this, `recursion limit reached ${_maxDepth}`);
     }
-    const scopes = this._scopes;
-    const scope = {
+    const scope = new ParseScope(
       id,
-      state: { ...scopes[scopes.length - 1].state },
-      children: null,
-      result: null
-    };
+      scopes[scopes.length - 1].state.copy()
+    );
     scopes.push(scope);
     this._peakDepth = Math.max(this._peakDepth, scopes.length);
     this._debug && console.log(
@@ -62,11 +83,10 @@ class ParseContext {
     const child = scopes.pop();
     const parent = scopes[scopes.length - 1];
     const cstate = child.state;
-    let pstate;
     this._debug && console.log(
       `${__indent(scopes.length + 1)}end: ${child.id} (${cstate.p})`
     );
-    child.state = this._retain ? (pstate = parent.state, { p: pstate.p, l: pstate.l, c: pstate.c }) : null;
+    child.state = this._retain ? parent.state.copy() : null;
     parent.state = cstate;
     const children = parent.children;
     children ? children.push(child) : parent.children = [child];
@@ -75,20 +95,19 @@ class ParseContext {
   }
   addChild(id, result = null, newState = false) {
     const curr = this._curr;
-    const cstate = curr.state;
-    const child = {
+    const child = new ParseScope(
       id,
-      state: this._retain ? { p: cstate.p, l: cstate.l, c: cstate.c } : null,
-      children: null,
+      this._retain ? curr.state.copy() : null,
+      null,
       result
-    };
+    );
     this._debug && console.log(
-      `${__indent(this._scopes.length + 1)}addChild: ${id} (${cstate.p})`
+      `${__indent(this._scopes.length + 1)}addChild: ${id} (${curr.state.p})`
     );
     const children = curr.children;
     children ? children.push(child) : curr.children = [child];
     if (newState !== false) {
-      newState === true ? this.reader.next(cstate) : this._curr.state = newState;
+      newState === true ? this.reader.next(curr.state) : this._curr.state = newState;
     }
     return true;
   }
@@ -140,5 +159,7 @@ function defContext(input, opts) {
 }
 export {
   ParseContext,
+  ParseScope,
+  ParseState,
   defContext
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thi.ng/parse",
-  "version": "2.4.51",
+  "version": "2.4.52",
   "description": "Purely functional parser combinators & AST generation for generic inputs",
   "type": "module",
   "module": "./index.js",
@@ -240,5 +240,5 @@
     ],
     "year": 2020
   },
-  "gitHead": "f6e26ea1142525171de5d36b9c3119f2782bb437\n"
+  "gitHead": "66e4c19b3054a6c35500a3e1acea1bf2563b14e8\n"
 }

package/prims/skip.js

@@ -1,5 +1,5 @@
 const skipWhile = (pred) => (ctx) => {
-  const state = { ...ctx.state };
+  const state = ctx.state.copy();
   const reader = ctx.reader;
   while (!state.done) {
     if (!pred(reader.read(state))) break;

package/prims/string.js

@@ -16,7 +16,7 @@ const string = (str, id = "string") => (ctx) => {
 };
 const stringD = (str) => (ctx) => {
   if (ctx.done) return false;
-  const state = { ...ctx.state };
+  const state = ctx.state.copy();
   const reader = ctx.reader;
   for (let i = 0, n = str.length; i < n; i++) {
     if (state.done) return false;
@@ -30,7 +30,7 @@ const stringD = (str) => (ctx) => {
   return true;
 };
 const stringOf = (pred, id = "string", reduce = (x) => x.join("")) => (ctx) => {
-  const state = { ...ctx.state };
+  const state = ctx.state.copy();
   const reader = ctx.reader;
   let acc = [];
   while (!state.done) {

package/readers/array-reader.d.ts

@@ -1,4 +1,5 @@
-import type { ParseState, IReader } from "../api.js";
+import type { IReader } from "../api.js";
+import type { ParseState } from "../context.js";
 export declare class ArrayReader<T> implements IReader<T> {
     protected _src: ArrayLike<T>;
     constructor(_src: ArrayLike<T>);

package/readers/string-reader.d.ts

@@ -1,4 +1,5 @@
-import type { ParseState, IReader } from "../api.js";
+import type { IReader } from "../api.js";
+import type { ParseState } from "../context.js";
 export declare class StringReader implements IReader<string> {
     protected _src: string;
     constructor(_src: string);

package/xform/count.js

@@ -1,6 +1,6 @@
 import { xform } from "../combinators/xform.js";
 const xfCount = (scope) => {
-  scope.result = scope.children ? scope.children.length : 0;
+  scope.result = scope.children?.length || 0;
   scope.children = null;
   return scope;
 };

package/xform/join.d.ts

@@ -1,5 +1,6 @@
 import type { Nullable } from "@thi.ng/api";
-import type { Parser, ParseScope } from "../api.js";
+import type { Parser } from "../api.js";
+import type { ParseScope } from "../context.js";
 /**
  * Recursively joins non-null results of all children into a single
  * string, then discards children. Also see {@link join}.

package/xform/nest.d.ts

@@ -5,7 +5,7 @@ import type { Parser, ScopeTransform } from "../api.js";
  *
  * @remarks
  * The nested parser is applied to a separate {@link ParseContext} and if
- * successful, the resulting AST will be transplated into the current parse
+ * successful, the resulting AST will be transplanted into the current parse
  * scope. If the nested parser fails, the scope will remain untouched.
  *
  * If the current parse context retains line/column details, the inner parse

package/xform/nest.js

@@ -3,7 +3,7 @@ import { defContext } from "../context.js";
 import { xfJoin } from "./join.js";
 const xfNest = (parser) => (scope, ctx) => {
   if (!scope) return;
-  const src = scope.result || xfJoin({ ...scope }).result;
+  const src = scope.result || xfJoin(scope.copy()).result;
   const inner = defContext(src, ctx.opts);
   const state = scope.state;
   if (state) {