tarsec 0.0.7 → 0.0.9

package/README.md

@@ -19,14 +19,14 @@ npm install tarsec
 ## Hello world
 
 ```ts
-import { str, seq, space } from "tarsec";
+import { getResults, str, seq, space } from "tarsec";
 
 // define a parser
 const parser = seq([
     str("hello"),
     space,
     str("world")
-]);
+], getResults);
 
 // then use it
 parser("hello world"); // success
@@ -55,12 +55,12 @@ const parser = seq([
     */
     capture(many1WithJoin(noneOf("!")), "person"),
     char("!"),
-]);
+], getCaptures);
 
 // parse
-const result = parser("hello adit!");
+const parsed = parser("hello adit!");
 
-console.log(result.success); // true
-console.log(result.captures); // { person: "adit" }
+console.log(parsed.success); // true
+console.log(parsed.result); // { person: "adit" }
 ```
 

package/dist/combinators.d.ts

@@ -1,15 +1,17 @@
-import { Parser } from "./types";
+import { CaptureParser, GeneralParser, MergedCaptures, MergedResults, Parser, Prettify } from "./types";
 export declare function many<T>(parser: Parser<T>): Parser<T[]>;
 export declare function many1<T>(parser: Parser<T>): Parser<T[]>;
+export declare function count<T>(parser: Parser<T>): Parser<number>;
 export declare function manyWithJoin(parser: Parser<string>): Parser<string>;
 export declare function many1WithJoin(parser: Parser<string>): Parser<string>;
-export declare function or<T>(parsers: Parser<T>[], name?: string): Parser<T>;
+export declare function or<const T extends readonly Parser<any>[]>(parsers: T, name?: string): Parser<MergedResults<T>>;
 export declare function optional<T>(parser: Parser<T>): Parser<T | null>;
 export declare function not(parser: Parser<any>): Parser<null>;
 export declare function between<O, C, P>(open: Parser<O>, close: Parser<C>, parser: Parser<P>): Parser<P>;
 export declare function sepBy<S, P>(separator: Parser<S>, parser: Parser<P>): Parser<P[]>;
-export declare function seq<M, C extends string>(parsers: Parser<M>[], name?: string): Parser<M[], C>;
-export declare function capture<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
-export declare function captureCaptures<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
-export declare function shapeCaptures<M, C extends string>(parser: Parser<M>, func: (captures: Record<string, any>) => Record<string, any>, name: string): Parser<M, C>;
+export declare function getResults<R, C>(results: R, captures: C): R;
+export declare function getCaptures<R, C>(results: R, captures: C): C;
+export declare function seq<const T extends readonly GeneralParser<any, any>[], U>(parsers: T, transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U, debugName?: string): Parser<U>;
+export declare function capture<T, const S extends string>(parser: Parser<T>, name: S): CaptureParser<T, Record<S, T>>;
+export declare function wrap<T, const S extends string>(parser: Parser<T>, name: S): Parser<Prettify<Record<S, T>>>;
 export declare function transform<T, X>(parser: Parser<T>, transformerFunc: (x: T) => X): Parser<X>;

package/dist/combinators.js

@@ -4,25 +4,26 @@
         if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./trace", "./utils"], factory);
+        define(["require", "exports", "./trace", "./types", "./utils"], factory);
     }
 })(function (require, exports) {
     "use strict";
     Object.defineProperty(exports, "__esModule", { value: true });
-    exports.transform = exports.shapeCaptures = exports.captureCaptures = exports.capture = exports.seq = exports.sepBy = exports.between = exports.not = exports.optional = exports.or = exports.many1WithJoin = exports.manyWithJoin = exports.many1 = exports.many = void 0;
+    exports.transform = exports.wrap = exports.capture = exports.seq = exports.getCaptures = exports.getResults = exports.sepBy = exports.between = exports.not = exports.optional = exports.or = exports.many1WithJoin = exports.manyWithJoin = exports.count = exports.many1 = exports.many = void 0;
     const trace_1 = require("./trace");
+    const types_1 = require("./types");
     const utils_1 = require("./utils");
     function many(parser) {
         return (0, trace_1.trace)("many", (input) => {
-            let match = [];
+            let results = [];
             let rest = input;
             while (true) {
-                let result = parser(rest);
-                if (!result.success) {
-                    return { success: true, match, rest };
+                let parsed = parser(rest);
+                if (!parsed.success) {
+                    return (0, types_1.success)(results, rest);
                 }
-                match.push(result.match);
-                rest = result.rest;
+                results.push(parsed.result);
+                rest = parsed.rest;
             }
         });
     }
@@ -42,6 +43,16 @@
         });
     }
     exports.many1 = many1;
+    function count(parser) {
+        return (0, trace_1.trace)("count", (input) => {
+            const result = many(parser)(input);
+            if (result.success) {
+                return (0, types_1.success)(result.result.length, result.rest);
+            }
+            return result;
+        });
+    }
+    exports.count = count;
     function manyWithJoin(parser) {
         return transform(many(parser), (x) => x.join(""));
     }
@@ -50,6 +61,10 @@
         return transform(many1(parser), (x) => x.join(""));
     }
     exports.many1WithJoin = many1WithJoin;
+    /* seq<, U>(
+      parsers: T,
+      transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U,
+     */
     function or(parsers, name = "") {
         return (0, trace_1.trace)(`or(${name})`, (input) => {
             for (let parser of parsers) {
@@ -58,11 +73,7 @@
                     return result;
                 }
             }
-            return {
-                success: false,
-                rest: input,
-                message: "all parsers failed",
-            };
+            return (0, types_1.failure)(`all parsers failed`, input);
         });
     }
     exports.or = or;
@@ -72,7 +83,7 @@
             if (result.success) {
                 return result;
             }
-            return { success: true, match: null, rest: input };
+            return (0, types_1.success)(null, input);
         });
     }
     exports.optional = optional;
@@ -86,7 +97,7 @@
                     message: "unexpected match",
                 };
             }
-            return { success: true, match: null, rest: input };
+            return (0, types_1.success)(null, input);
         });
     }
     exports.not = not;
@@ -104,95 +115,157 @@
             if (!result2.success) {
                 return result2;
             }
-            return { success: true, match: parserResult.match, rest: result2.rest };
+            return (0, types_1.success)(parserResult.result, result2.rest);
         };
     }
     exports.between = between;
     function sepBy(separator, parser) {
         return (input) => {
-            let match = [];
+            let results = [];
             let rest = input;
             while (true) {
                 const result = parser(rest);
                 if (!result.success) {
-                    return { success: true, match, rest };
+                    return (0, types_1.success)(results, rest);
                 }
-                match.push(result.match);
+                results.push(result.result);
                 rest = result.rest;
                 const sepResult = separator(rest);
                 if (!sepResult.success) {
-                    return { success: true, match, rest };
+                    return (0, types_1.success)(results, rest);
                 }
                 rest = sepResult.rest;
             }
         };
     }
     exports.sepBy = sepBy;
-    function seq(parsers, name = "") {
-        return (0, trace_1.trace)(`seq(${name})`, (input) => {
-            let match = [];
+    function getResults(results, captures) {
+        return results;
+    }
+    exports.getResults = getResults;
+    function getCaptures(results, captures) {
+        return captures;
+    }
+    exports.getCaptures = getCaptures;
+    function seq(parsers, transform, debugName = "") {
+        return (0, trace_1.trace)(`seq(${debugName})`, (input) => {
+            const results = [];
             let rest = input;
-            // @ts-ignore
-            let captures = {};
+            const captures = {};
             for (let parser of parsers) {
-                let result = parser(rest);
-                if (!result.success) {
-                    return result;
+                let parsed = parser(rest);
+                if (!parsed.success) {
+                    return parsed;
                 }
-                match.push(result.match);
-                rest = result.rest;
-                if (result.captures) {
-                    captures = (0, utils_1.mergeCaptures)(captures, result.captures);
+                results.push(parsed.result);
+                rest = parsed.rest;
+                if ((0, types_1.isCaptureResult)(parsed)) {
+                    for (const key in parsed.captures) {
+                        captures[key] = parsed.captures[key];
+                    }
                 }
             }
-            return { success: true, match, rest, captures };
+            const result = transform(results, captures);
+            return (0, types_1.success)(result, rest);
         });
     }
     exports.seq = seq;
     function capture(parser, name) {
-        return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+        return (0, trace_1.trace)(`capture(${(0, utils_1.escape)(name)})`, (input) => {
             let result = parser(input);
             if (result.success) {
                 const captures = {
-                    [name]: result.match,
+                    [name]: result.result,
                 };
-                return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
+                return Object.assign(Object.assign({}, result), { captures });
             }
             return result;
         });
     }
     exports.capture = capture;
-    function captureCaptures(parser, name) {
-        return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
+    function wrap(parser, name) {
+        return (0, trace_1.trace)(`capture(${(0, utils_1.escape)(name)})`, (input) => {
             let result = parser(input);
             if (result.success) {
-                const captures = {
-                    [name]: result.captures,
-                };
-                return Object.assign(Object.assign({}, result), { captures: (0, utils_1.mergeCaptures)(result.captures || {}, captures) });
+                return Object.assign(Object.assign({}, result), { result: {
+                        [name]: result.result,
+                    } });
             }
             return result;
         });
     }
-    exports.captureCaptures = captureCaptures;
-    function shapeCaptures(parser, func, name) {
-        return (0, trace_1.trace)(`captures(${(0, utils_1.escape)(name)})`, (input) => {
-            let result = parser(input);
-            if (result.success) {
-                const captures = result.captures || {};
-                return Object.assign(Object.assign({}, result), { captures: func(captures) });
-            }
-            return result;
-        });
+    exports.wrap = wrap;
+    /*
+    export function setCapturesAsMatch<M, C extends PlainObject>(
+      parser: Parser<M, C>
+    ): Parser<C> {
+      return trace(`setCapturesAsMatch`, (input: string) => {
+        let result = parser(input);
+        if (result.success) {
+          return {
+            ...result,
+            match: result.captures as any,
+            captures: {},
+          };
+        }
+        return result;
+      });
+    }
+    
+    export function captureCaptures<
+      M,
+      C extends PlainObject,
+      const S extends string
+    >(parser: Parser<M, C>, name: S): Parser<C, Record<S, C>> {
+      return trace(`captureCaptures(${escape(name)})`, (input: string) => {
+        return capture(setCapturesAsMatch(parser), name)(input);
+      });
+    } */
+    /* export function captureCaptures<M, C extends string>(
+      parser: Parser<M>,
+      name: string
+    ): Parser<M, C> {
+      return trace(`captures(${escape(name)})`, (input: string) => {
+        let result = parser(input);
+        if (result.success) {
+          const captures: Record<string, any> = {
+            [name]: result.captures,
+          };
+          return {
+            ...result,
+            captures: mergeCaptures(result.captures || {}, captures),
+          };
+        }
+        return result;
+      });
     }
-    exports.shapeCaptures = shapeCaptures;
+    
+     */
+    /* export function shapeCaptures<M, C extends string>(
+      parser: Parser<M>,
+      func: (captures: Record<string, any>) => Record<string, any>,
+      name: string
+    ): Parser<M, C> {
+      return trace(`captures(${escape(name)})`, (input: string) => {
+        let result = parser(input);
+        if (result.success) {
+          const captures: Record<string, any> = result.captures || {};
+    
+          return {
+            ...result,
+            captures: func(captures),
+          };
+        }
+        return result;
+      });
+    } */
     function transform(parser, transformerFunc) {
         return (0, trace_1.trace)(`transform(${transformerFunc})`, (input) => {
-            let result = parser(input);
-            if (result.success) {
-                return Object.assign(Object.assign({}, result), { match: transformerFunc(result.match) });
+            let parsed = parser(input);
+            if (parsed.success) {
+                return Object.assign(Object.assign({}, parsed), { result: transformerFunc(parsed.result) });
             }
-            return result;
+            return parsed;
         });
     }
     exports.transform = transform;

package/dist/lib/combinators.d.ts

@@ -1,15 +1,17 @@
-import { Parser } from "./types";
+import { CaptureParser, GeneralParser, MergedCaptures, MergedResults, Parser, Prettify } from "./types";
 export declare function many<T>(parser: Parser<T>): Parser<T[]>;
 export declare function many1<T>(parser: Parser<T>): Parser<T[]>;
+export declare function count<T>(parser: Parser<T>): Parser<number>;
 export declare function manyWithJoin(parser: Parser<string>): Parser<string>;
 export declare function many1WithJoin(parser: Parser<string>): Parser<string>;
-export declare function or<T>(parsers: Parser<T>[], name?: string): Parser<T>;
+export declare function or<const T extends readonly Parser<any>[]>(parsers: T, name?: string): Parser<MergedResults<T>>;
 export declare function optional<T>(parser: Parser<T>): Parser<T | null>;
 export declare function not(parser: Parser<any>): Parser<null>;
 export declare function between<O, C, P>(open: Parser<O>, close: Parser<C>, parser: Parser<P>): Parser<P>;
 export declare function sepBy<S, P>(separator: Parser<S>, parser: Parser<P>): Parser<P[]>;
-export declare function seq<M, C extends string>(parsers: Parser<M>[], name?: string): Parser<M[], C>;
-export declare function capture<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
-export declare function captureCaptures<M, C extends string>(parser: Parser<M>, name: string): Parser<M, C>;
-export declare function shapeCaptures<M, C extends string>(parser: Parser<M>, func: (captures: Record<string, any>) => Record<string, any>, name: string): Parser<M, C>;
+export declare function getResults<R, C>(results: R, captures: C): R;
+export declare function getCaptures<R, C>(results: R, captures: C): C;
+export declare function seq<const T extends readonly GeneralParser<any, any>[], U>(parsers: T, transform: (results: MergedResults<T>[], captures: MergedCaptures<T>) => U, debugName?: string): Parser<U>;
+export declare function capture<T, const S extends string>(parser: Parser<T>, name: S): CaptureParser<T, Record<S, T>>;
+export declare function wrap<T, const S extends string>(parser: Parser<T>, name: S): Parser<Prettify<Record<S, T>>>;
 export declare function transform<T, X>(parser: Parser<T>, transformerFunc: (x: T) => X): Parser<X>;