tarsec 0.4.0 → 0.4.2

package/dist/combinators.d.ts

@@ -82,6 +82,28 @@ export declare function optional<T>(parser: Parser<T>): Parser<T | null>;
  * If it succeeds, returns a failure.
  */
 export declare function not(parser: Parser<any>): Parser<null>;
+/**
+ * Positive lookahead. Runs the given parser without consuming any input.
+ * On success, returns the parser's result with `rest` set to the original input.
+ * On failure, returns the underlying failure (also with `rest` reset to the original input).
+ *
+ * Useful for disambiguating alternatives without backtracking:
+ *
+ * ```ts
+ * const parser = or(
+ *   seqR(peek(str("hello!")), str("hello!")),
+ *   str("hello"),
+ * );
+ * ```
+ *
+ * The `peek` decides which branch to commit to; the real parser then consumes.
+ * Captures are preserved when the inner parser is a `CaptureParser`.
+ *
+ * @param parser - parser to look ahead with
+ * @returns - a parser that runs the given parser without consuming input
+ */
+export declare function peek<T>(parser: Parser<T>): Parser<T>;
+export declare function peek<T, C extends PlainObject>(parser: CaptureParser<T, C>): CaptureParser<T, C>;
 /**
  * Takes three parsers, `open`, `close`, and `parser`.
  * `between` matches multiple instances of `parser`,
@@ -475,3 +497,21 @@ export type OperatorInfo<T> = {
  * @returns - a parser that handles the full expression grammar
  */
 export declare function buildExpressionParser<T>(atom: Parser<T>, operatorTable: OperatorInfo<T>[][], parenParser?: Parser<T>): Parser<T>;
+/**
+ * Wraps a parser with a per-input cache. Useful for parsers that may be invoked
+ * many times at the same position (e.g. recursive grammars where the same
+ * sub-parser is consulted from multiple alternatives).
+ *
+ * Both successes and failures are cached. The cache is keyed by the input
+ * string the parser is called with — because the rest passed between parsers
+ * is value-equal across paths, identical sub-parses share a cache entry.
+ *
+ * `memo` assumes its wrapped parser is a pure function of its input. Don't
+ * memoize parsers that consult mutable external state.
+ *
+ * @param name - optional debug name (shown in `parserDebug` counts/times as `memo(name)`)
+ * @param parser - parser to memoize
+ * @returns - memoized parser
+ */
+export declare function memo<T>(name: string, parser: Parser<T>): Parser<T>;
+export declare function memo<T, C extends PlainObject>(name: string, parser: CaptureParser<T, C>): CaptureParser<T, C>;

package/dist/combinators.js

@@ -202,6 +202,15 @@ export function not(parser) {
         return success(null, input);
     });
 }
+export function peek(parser) {
+    return trace("peek", (input) => {
+        const result = parser(input);
+        if (!result.success) {
+            return Object.assign(Object.assign({}, result), { rest: input });
+        }
+        return Object.assign(Object.assign({}, result), { rest: input });
+    });
+}
 /**
  * Takes three parsers, `open`, `close`, and `parser`.
  * `between` matches multiple instances of `parser`,
@@ -923,3 +932,20 @@ function tryOps(ops, input) {
     }
     return null;
 }
+const DEFAULT_MEMO_LIMIT = 10000;
+export function memo(name, parser) {
+    const cache = new Map();
+    return trace(name ? `memo(${name})` : "memo", (input) => {
+        const hit = cache.get(input);
+        if (hit !== undefined)
+            return hit;
+        const result = parser(input);
+        if (cache.size >= DEFAULT_MEMO_LIMIT) {
+            const oldest = cache.keys().next().value;
+            if (oldest !== undefined)
+                cache.delete(oldest);
+        }
+        cache.set(input, result);
+        return result;
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tarsec",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "A parser combinator library for TypeScript, inspired by Parsec.",
   "homepage": "https://github.com/egonSchiele/tarsec",
   "scripts": {