securemark 0.299.4 → 0.300.1

package/src/api.ts

@@ -1,3 +1,4 @@
+export { run } from './api/run';
 export { parse } from './api/parse';
 export { bind } from './api/bind';
 export { caches } from './api/cache';

package/src/combinator/control/inits.ts

@@ -0,0 +1,35 @@
+import { Parser, SubParsers, Result } from '../parser';
+import { union } from './union';
+import { sequence } from './sequence';
+
+export function inits<P extends Parser>(parsers: Parser.SubParsers<P>): P;
+export function inits<T>(parsers: SubParsers<T>): Parser<T> {
+  assert(parsers.every(f => f));
+  switch (parsers.length) {
+    case 0:
+      assert(false);
+      return (_, output) => output.context;
+    case 1:
+      return parsers[0];
+    default:
+      return parsers.reduceRight((acc, parser, i) =>
+        sequence([
+          parser,
+          i !== 0
+            ? acc
+            : union([
+                acc,
+                recovery,
+              ]),
+        ]));
+  }
+}
+
+const recovery: Parser<never> = (_, output) => {
+  if (output.state) {
+    output.state = true;
+    // @ts-expect-error
+    output.context ??= Result.succ;
+  }
+  return output.context;
+};

package/src/combinator/control/sequence.test.ts

@@ -0,0 +1,38 @@
+import { Parser, Result, Input, Node, input } from '../parser';
+import { sequence } from './sequence';
+import { backtrack } from '../effect/backtrack';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/control/sequence', () => {
+  describe('sequence', () => {
+    const A: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'A'){
+        ++input.position;
+        output.append(new Node('a'));
+        return Result.succ;
+      }
+    };
+    const B: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'B'){
+        ++input.position;
+        output.append(new Node('b'));
+        return Result.succ;
+      }
+    };
+    const AB = backtrack(sequence<Parser<string, Input, [typeof A, typeof B]>>([A, B]));
+
+    it('basic', () => {
+      const parser = AB;
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('A')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('B')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('AB')), [['a', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('BA')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('AAB')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('ABB')), [['a', 'b'], 'B']);
+      assert.deepStrictEqual(inspect(parser, input('BBA')), undefined);
+    });
+
+  });
+
+});

package/src/combinator/control/sequence.ts

@@ -0,0 +1,19 @@
+import { Parser, SubParsers } from '../parser';
+import { success, always } from './state';
+
+export function sequence<P extends Parser>(parsers: Parser.SubParsers<P>): P;
+export function sequence<T>(parsers: SubParsers<T>): Parser<T> {
+  assert(parsers.every(f => f));
+  switch (parsers.length) {
+    case 0:
+      assert(false);
+      return (_, output) => output.context;
+    case 1:
+      return parsers[0];
+    default:
+      return parsers.reduceRight((acc, parser) => always([
+        parser,
+        success(acc),
+      ]));
+  }
+}

package/src/combinator/control/some.test.ts

@@ -0,0 +1,41 @@
+import { Parser, Result, Input, Node, input } from '../parser';
+import { union } from './union';
+import { some } from './some';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/control/some', () => {
+  describe('some', () => {
+    const A: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'A'){
+        ++input.position;
+        output.append(new Node('a'));
+        return Result.succ;
+      }
+    };
+    const B: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'B'){
+        ++input.position;
+        output.append(new Node('b'));
+        return Result.succ;
+      }
+    };
+    const AB = union<Parser<string, Input, [typeof A, typeof B]>>([A, B]);
+
+    it('basic', () => {
+      const parser = some(AB, /AAA/y);
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('A')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('B')), [['b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('AB')), [['a', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('BA')), [['b', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('AAB')), [['a', 'a', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('BBA')), [['b', 'b', 'a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('AAA')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('BBB')), [['b', 'b', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('AAAB')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('BAAA')), [['b'], 'AAA']);
+    });
+
+  });
+
+});

package/src/combinator/{data/parser → control}/some.ts

@@ -1,5 +1,6 @@
-import { Parser, List, Node } from '../parser';
+import { Parser, Result, Input } from '../parser';
 import { Delimiters } from '../delimiter';
+import { always } from './state';
 
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
@@ -7,7 +8,7 @@ export function some<P extends Parser>(parser: P, limit?: number): P;
 export function some<P extends Parser>(parser: P, delimiters?: readonly DelimiterOption[], limit?: number): P;
 export function some<P extends Parser>(parser: P, delimiter: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
 export function some<P extends Parser>(parser: P, delimiter: string | RegExp, after: string | RegExp, delimiters?: readonly DelimiterOption[], limit?: number): P;
-export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp | readonly DelimiterOption[], after?: number | string | RegExp | readonly DelimiterOption[], delimiters?: number | readonly DelimiterOption[], limit = 0): Parser<N> {
+export function some<T>(parser: Parser<T>, delimiter?: number | string | RegExp | readonly DelimiterOption[], after?: number | string | RegExp | readonly DelimiterOption[], delimiters?: number | readonly DelimiterOption[], limit = 0): Parser<T> {
   if (typeof delimiter === 'number') {
     limit = delimiter;
     delimiters = undefined;
@@ -29,33 +30,45 @@ export function some<N>(parser: Parser<N>, delimiter?: number | string | RegExp
   assert(parser);
   assert(delimiter !== '');
   assert(delimiters === undefined || Array.isArray(delimiters));
-  const match = Delimiters.tester(delimiter as string, after as string);
+  const test = Delimiters.tester(delimiter as string, after as string);
   const delims = delimiters?.map(([delimiter, precedence]) => ({
     signature: Delimiters.signature(delimiter),
     tester: Delimiters.tester(delimiter),
     precedence,
   }));
-  return input => {
-    const context = input;
-    const { source, position } = context;
-    let nodes: List<Node<N>> | undefined;
-    delims && context.delimiters.push(delims);
-    // whileは数倍遅い
-    for (const len = source.length; context.position < len;) {
-      if (match(input)) break;
-      if (context.delimiters.test(input)) break;
-      const pos = context.position;
-      const result = parser(input);
-      if (result === undefined) break;
-      if (context.position === pos) break;
-      nodes = nodes?.import(result) ?? result;
-      // 次にパースに成功すれば確実に制限値を超えるので制限値ちょうどでも中止する
-      if (limit > 0 && context.position - position >= limit) break;
-    }
-    delims && context.delimiters.pop(delims.length);
-    assert(context.position >= position);
-    return context.position > position
-      ? nodes
-      : undefined;
-  };
+  interface Memory {
+    readonly position: number;
+  }
+  // 末尾再帰
+  const loop: Result<T, Input<Memory>> = [
+    (input, output) =>
+      test(input, output) || input.delimiters.test(input, output)
+        ? Result.skip
+        : Result.succ,
+    parser,
+    (input, output) =>
+      output.state
+        // 次にパースに成功すれば確実に制限値を超えるので制限値ちょうどでも中止する
+        ? input.position === input.source.length || limit !== 0 && input.position - input.memory.position >= limit
+          ? Result.succ
+          : loop
+        : Result.fail,
+  ];
+  return always<Parser<T, Input<Memory>>>([
+    input => {
+      const { source, position } = input;
+      if (position === source.length) return Result.skip;
+      input.memory = {
+        position,
+      };
+      delims && input.delimiters.push(delims);
+      return loop;
+    },
+    input => {
+      delims && input.delimiters.pop(delims.length);
+      return input.position > input.memory.position
+        ? Result.succ
+        : Result.fail;
+    },
+  ]);
 }

package/src/combinator/control/state.ts

@@ -0,0 +1,33 @@
+import { Parser, SubParsers } from '../parser';
+
+export function then<P extends Parser>(success: P, failure: P): P;
+export function then<T>(success: Parser<T>, failure: Parser<T>): Parser<T> {
+  assert(success);
+  assert(failure);
+  return (input, output) => output.state ? success(input, output) : failure(input, output);
+}
+
+export function success<P extends Parser>(parser: P): P;
+export function success<T>(parser: Parser<T>): Parser<T> {
+  assert(parser);
+  return (input, output) => output.context && parser(input, output);
+}
+
+export function failure<P extends Parser>(parser: P): P;
+export function failure<T>(parser: Parser<T>): Parser<T> {
+  assert(parser);
+  return (input, output) => output.context ?? parser(input, output);
+}
+
+export function always<P extends Parser>(parsers: readonly P[]): P;
+export function always<T, S extends SubParsers<T>>(parsers: S): Parser<T> {
+  return () => parsers;
+}
+
+export function force<P extends Parser>(parser: P): P;
+export function force<T>(parser: Parser<T>): Parser<T> {
+  return (input, output) =>
+    input.position === input.source.length
+      ? output.context
+      : parser(input, output);
+}

package/src/combinator/control/subsequence.test.ts

@@ -0,0 +1,47 @@
+import { Parser, Result, Input, Node, input } from '../parser';
+import { subsequence } from './subsequence';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/control/subsequence', () => {
+  describe('subsequence', () => {
+    const A: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'A'){
+        ++input.position;
+        output.append(new Node('a'));
+        return Result.succ;
+      }
+    };
+    const B: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'B'){
+        ++input.position;
+        output.append(new Node('b'));
+        return Result.succ;
+      }
+    };
+    const C: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'C'){
+        ++input.position;
+        output.append(new Node('c'));
+        return Result.succ;
+      }
+    };
+    const ABC = subsequence<Parser<string, Input, [typeof A, typeof B, typeof C]>>([A, B, C]);
+
+    it('basic', () => {
+      const parser = ABC;
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('A')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('B')), [['b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('C')), [['c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('AB')), [['a', 'b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('BA')), [['b'], 'A']);
+      assert.deepStrictEqual(inspect(parser, input('AAB')), [['a'], 'AB']);
+      assert.deepStrictEqual(inspect(parser, input('ABB')), [['a', 'b'], 'B']);
+      assert.deepStrictEqual(inspect(parser, input('BBA')), [['b'], 'BA']);
+      assert.deepStrictEqual(inspect(parser, input('AC')), [['a', 'c'], '']);
+      assert.deepStrictEqual(inspect(parser, input('BC')), [['b', 'c'], '']);
+    });
+
+  });
+
+});

package/src/combinator/control/subsequence.ts

@@ -0,0 +1,16 @@
+import { Parser, SubParsers } from '../parser';
+import { union } from './union';
+import { inits } from './inits';
+
+export function subsequence<P extends Parser>(parsers: Parser.SubParsers<P>): P;
+export function subsequence<T>(parsers: SubParsers<T>): Parser<T> {
+  assert(parsers.every(f => f));
+  return union(
+    parsers.map((_, i) =>
+      i + 1 !== parsers.length
+        ? inits([
+            parsers[i],
+            subsequence(parsers.slice(i + 1)),
+          ])
+        : parsers[i]));
+}

package/src/combinator/control/tails.ts

@@ -0,0 +1,8 @@
+import { Parser, SubParsers } from '../parser';
+import { union } from './union';
+import { sequence } from './sequence';
+
+export function tails<P extends Parser>(parsers: Parser.SubParsers<P>): P;
+export function tails<T>(parsers: SubParsers<T>): Parser<T> {
+  return union(parsers.map((_, i) => sequence(parsers.slice(i))));
+}

package/src/combinator/control/union.test.ts

@@ -0,0 +1,37 @@
+import { Parser, Result, Input, Node, input } from '../parser';
+import { union } from './union';
+import { inspect } from '../../debug.test';
+
+describe('Unit: lib/parser/control/union', () => {
+  describe('union', () => {
+    const A: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'A'){
+        ++input.position;
+        output.append(new Node('a'));
+        return Result.succ;
+      }
+    };
+    const B: Parser<string> = (input, output) => {
+      if(input.source[input.position] === 'B'){
+        ++input.position;
+        output.append(new Node('b'));
+        return Result.succ;
+      }
+    };
+    const AB = union<Parser<string, Input, [typeof A, typeof B]>>([A, B]);
+
+    it('basic', () => {
+      const parser = AB;
+      assert.deepStrictEqual(inspect(parser, input('')), undefined);
+      assert.deepStrictEqual(inspect(parser, input('A')), [['a'], '']);
+      assert.deepStrictEqual(inspect(parser, input('B')), [['b'], '']);
+      assert.deepStrictEqual(inspect(parser, input('AB')), [['a'], 'B']);
+      assert.deepStrictEqual(inspect(parser, input('BA')), [['b'], 'A']);
+      assert.deepStrictEqual(inspect(parser, input('AAB')), [['a'], 'AB']);
+      assert.deepStrictEqual(inspect(parser, input('ABB')), [['a'], 'BB']);
+      assert.deepStrictEqual(inspect(parser, input('BBA')), [['b'], 'BA']);
+    });
+
+  });
+
+});

package/src/combinator/control/union.ts

@@ -0,0 +1,31 @@
+import { Parser, SubParsers, Result } from '../parser';
+import { failure, always } from './state';
+
+export function union<P extends Parser>(parsers: Parser.SubParsers<P>): P;
+export function union<T>(parsers: SubParsers<T>): Parser<T> {
+  assert(parsers.every(f => f));
+  switch (parsers.length) {
+    case 0:
+      assert(false);
+      return (_, output) => output.context;
+    case 1:
+      return parsers[0];
+    default:
+      return parsers.reduceRight((acc, parser) => always([
+        parser,
+        failure(recovery(acc)),
+      ]));
+  }
+}
+
+function recovery<P extends Parser>(parser: P): P;
+function recovery<T>(parser: Parser<T>): Parser<T> {
+  return (input, output) => {
+    if (!output.state) {
+      output.state = true;
+      // @ts-expect-error
+      output.context ??= Result.succ;
+    }
+    return parser(input, output);
+  };
+}

package/src/combinator/{data/delimiter.ts → delimiter.ts}

@@ -1,10 +1,10 @@
-import { Parser, Input, List, Node, Context } from './parser';
-import { spend } from './parser/context';
+import { Input, Output } from './parser';
+import { spend } from './effect/clock';
 
 interface Delimiter {
   readonly memory: Delimiter[];
   readonly index: number;
-  readonly tester: (input: Input) => boolean | undefined;
+  readonly tester: (input: Input, output: Output<unknown>) => boolean;
   readonly precedence: number;
   state: boolean;
 }
@@ -42,17 +42,17 @@ export class Delimiters {
         return index(`/${pattern.source}`);
     }
   }
-  public static tester(pattern: string | RegExp | undefined, after?: string | RegExp): (input: Input<Context>) => true | undefined {
+  public static tester(pattern: string | RegExp | undefined, after?: string | RegExp): (input: Input, output: Output<unknown>) => boolean {
     switch (typeof pattern) {
       case 'undefined':
-        return () => undefined;
+        return () => false;
       case 'string':
       case 'object':
         const test = tester(pattern, false);
-        const verify = after ? tester(after, false) : undefined;
+        const verify = after && tester(after, false);
         return verify
-          ? input => test(input) !== undefined && verify(input) !== undefined || undefined
-          : input => test(input) !== undefined || undefined;
+          ? (input, output) => test(input, output) && verify(input, output)
+          : (input, output) => test(input, output);
     }
   }
   private readonly memories: Delimiter[][] = [];
@@ -68,7 +68,7 @@ export class Delimiters {
   public push(
     delims: readonly {
       readonly signature: number;
-      readonly tester: (input: Input) => boolean | undefined;
+      readonly tester: (input: Input, output: Output<unknown>) => boolean;
       readonly precedence: number;
     }[]
   ): void {
@@ -139,37 +139,25 @@ export class Delimiters {
       delimiters[indexes[i]].state = true;
     }
   }
-  public test(input: Input): boolean {
+  public test(input: Input, output: Output<unknown>): boolean {
     const { precedence } = input;
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];
       if (delimiter.precedence <= precedence || !delimiter.state) continue;
-      switch (delimiter.tester(input)) {
-        case true:
-          return true;
-        case false:
-          return false;
-        default:
-          continue;
-      }
+      if (delimiter.tester(input, output)) return true;
     }
     return false;
   }
 }
 
-export function matcher(pattern: string | RegExp, advance: boolean, after?: Parser<string>): Parser<string> {
+export function matcher(pattern: string | RegExp, advance: boolean, after?: (input: Input, output: Output<unknown>) => boolean): (input: Input, output: Output<unknown>) => string | undefined {
   assert(pattern instanceof RegExp ? !pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^') : true);
-  const count = typeof pattern === 'object'
-    ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
-    : false;
   let sid = 0, pos = 0, index = -1;
   switch (typeof pattern) {
     case 'string':
-      if (pattern === '') return () => new List([new Node(pattern)]);
-      return input => {
-        const context = input;
-        const { SID, source, position } = context;
+      return (input, output) => {
+        const { SID, source, position } = input;
         const hit = SID === sid && position === pos;
         index = hit
           ? index
@@ -177,19 +165,18 @@ export function matcher(pattern: string | RegExp, advance: boolean, after?: Pars
         sid = SID;
         pos = position;
         if (index === -1) return;
+        !hit && spend(input, output, pattern.length);
         if (advance) {
-          context.position += pattern.length;
+          input.position += pattern.length;
         }
-        const next = after?.(input);
-        return after
-          ? next && new List([new Node(pattern)]).import(next)
-          : new List([new Node(pattern)]);
+        return after?.(input, output) ?? true
+          ? pattern
+          : undefined;
       };
     case 'object':
       assert(pattern.sticky);
-      return input => {
-        const context = input;
-        const { SID, source, position } = context;
+      return (input, output) => {
+        const { SID, source, position } = input;
         const hit = SID === sid && position === pos;
         pattern.lastIndex = position;
         index = hit
@@ -199,48 +186,42 @@ export function matcher(pattern: string | RegExp, advance: boolean, after?: Pars
         pos = position;
         if (index === -1) return;
         const src = source.slice(position, index);
-        count && !hit && spend(context, src.length);
+        !hit && spend(input, output, src.length);
         if (advance) {
-          context.position = index;
+          input.position = index;
         }
-        const next = after?.(input);
-        return after
-          ? next && new List([new Node(src)]).import(next)
-          : new List([new Node(src)]);
+        return after?.(input, output) ?? true
+          ? src
+          : undefined;
       };
   }
 }
 
-export function tester(pattern: string | RegExp, advance: boolean, after?: Parser<unknown>): Parser<never> {
+export function tester(pattern: string | RegExp, advance: boolean, after?: (input: Input, output: Output<unknown>) => boolean): (input: Input, output: Output<unknown>) => boolean {
   assert(pattern instanceof RegExp ? !pattern.flags.match(/[gm]/) && pattern.sticky && !pattern.source.startsWith('^') : true);
-  const count = typeof pattern === 'object'
-    ? /[^^\\*+][*+]|{\d+,}/.test(pattern.source)
-    : false;
   let sid = 0, pos = 0, index = -1;
   switch (typeof pattern) {
     case 'string':
-      if (pattern === '') return () => new List();
-      return input => {
-        const context = input;
-        const { SID, source, position } = context;
+      if (pattern === '') return () => true;
+      return (input, output) => {
+        const { SID, source, position } = input;
         const hit = SID === sid && position === pos;
         index = hit
           ? index
           : source.startsWith(pattern, position) ? position : -1;
         sid = SID;
         pos = position;
-        if (index === -1) return;
+        if (index === -1) return false;
+        !hit && spend(input, output, pattern.length);
         if (advance) {
-          context.position += pattern.length;
+          input.position += pattern.length;
         }
-        if (after && after(input) === undefined) return;
-        return new List();
+        return after?.(input, output) ?? true;
       };
     case 'object':
       assert(pattern.sticky);
-      return input => {
-        const context = input;
-        const { SID, source, position } = context;
+      return (input, output) => {
+        const { SID, source, position } = input;
         const hit = SID === sid && position === pos;
         pattern.lastIndex = position;
         index = hit
@@ -248,14 +229,13 @@ export function tester(pattern: string | RegExp, advance: boolean, after?: Parse
           : pattern.test(source) ? pattern.lastIndex : -1;
         sid = SID;
         pos = position;
-        if (index === -1) return;
+        if (index === -1) return false;
         const len = index - position;
-        count && !hit && spend(context, len);
+        !hit && spend(input, output, len);
         if (advance) {
-          context.position = index;
+          input.position = index;
         }
-        if (after && after(input) === undefined) return;
-        return new List();
+        return after?.(input, output) ?? true;
       };
   }
 }