securemark 0.295.1 → 0.295.2

package/src/combinator/control/monad/fmap.ts

@@ -1,10 +1,10 @@
-import { Parser, List, Data, Ctx, SubParsers, Node, Context, IntermediateParser, SubNode } from '../../data/parser';
+import { Parser, List, Node, Context } from '../../data/parser';
 import { bind } from './bind';
 
-export function fmap<P extends Parser>(parser: IntermediateParser<P>, f: (nodes: List<Data<SubNode<P>>>, context: Context<P>) => List<Data<Node<P>>>): P;
-export function fmap<P extends Parser>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => List<Data<Node<P>>>): P;
-export function fmap<N, P extends Parser>(parser: Parser<N, Context<P>, SubParsers<P>>, f: (nodes: List<Data<N>>, context: Context<P>) => List<Data<Node<P>>>): P;
-export function fmap<U, P extends Parser>(parser: P, f: (nodes: List<Data<Node<P>>>, context: Context<P>) => List<Data<U>>): Parser<U, Context<P>, SubParsers<P>>;
-export function fmap<N, U>(parser: Parser<N>, f: (nodes: List<Data<N>>, context: Ctx) => List<Data<U>>): Parser<U> {
+export function fmap<P extends Parser>(parser: Parser.IntermediateParser<P>, f: (nodes: List<Node<Parser.SubNode<P>>>, context: Parser.Context<P>) => List<Node<Parser.Node<P>>>): P;
+export function fmap<P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => List<Node<Parser.Node<P>>>): P;
+export function fmap<N, P extends Parser>(parser: Parser<N, Parser.Context<P>, Parser.SubParsers<P>>, f: (nodes: List<Node<N>>, context: Parser.Context<P>) => List<Node<Parser.Node<P>>>): P;
+export function fmap<U, P extends Parser>(parser: P, f: (nodes: List<Node<Parser.Node<P>>>, context: Parser.Context<P>) => List<Node<U>>): Parser<U, Parser.Context<P>, Parser.SubParsers<P>>;
+export function fmap<N, U>(parser: Parser<N>, f: (nodes: List<Node<N>>, context: Context) => List<Node<U>>): Parser<U> {
   return bind(parser, (nodes, context) => f(nodes, context));
 }

package/src/combinator/data/data.ts

@@ -1,6 +1,6 @@
-import { Parser, Ctx } from './parser';
+import { Parser, Context } from './parser';
 
-export class List<N extends List.Node = List.Node, C extends Ctx = Ctx, D extends Parser<unknown, C>[] = any> {
+export class List<N extends List.Node = List.Node, C extends Context = Context, D extends Parser<unknown, C>[] = any> {
   constructor(nodes?: ArrayLike<N>) {
     if (nodes === undefined) return;
     for (let i = 0; i < nodes.length; ++i) {

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

@@ -1,5 +1,5 @@
-import { Input, Ctx } from '../../parser';
-import { matcher } from '../../../../combinator';
+import { Input, Context } from './parser';
+import { matcher } from '../../combinator';
 
 interface Delimiter {
   readonly memory: Delimiter[];
@@ -27,7 +27,7 @@ export class Delimiters {
         return `r/${pattern.source}`;
     }
   }
-  public static matcher(pattern: string | RegExp | undefined): (input: Input<Ctx>) => true | undefined {
+  public static matcher(pattern: string | RegExp | undefined): (input: Input<Context>) => true | undefined {
     switch (typeof pattern) {
       case 'undefined':
         return () => undefined;
@@ -130,7 +130,7 @@ export class Delimiters {
     }
   }
   public match(input: Input): boolean {
-    const { precedence = 0 } = input.context;
+    const { precedence } = input.context;
     const { delimiters } = this;
     for (let i = delimiters.length; i--;) {
       const delimiter = delimiters[i];

package/src/combinator/data/parser/context.test.ts

@@ -1,23 +1,24 @@
-import { Parser, List, Data, Ctx, CtxOptions, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { some } from './some';
 import { reset, context, creation } from './context';
 import { unwrap } from '../../../parser/util';
 
 describe('Unit: combinator/data/parser/context', () => {
-  interface Context extends CtxOptions {
+  interface Ctx extends Context {
     status?: boolean;
   }
+  type Opts = Partial<Ctx>;
 
   describe('reset', () => {
     const parser: Parser<number> = some(creation(1,
       ({ context }) => {
         context.position += 1;
-        return new List([new Data(context.resources?.clock ?? NaN)]);
+        return new List([new Node(context.resources?.clock ?? NaN)]);
       }));
 
     it('root', () => {
-      const base: Context = { resources: { clock: 3, recursions: [1] } };
-      const ctx: Context = {};
+      const base: Opts = { resources: { clock: 3, recursions: [1] } };
+      const ctx: Ctx = new Context();
       assert.deepStrictEqual([...unwrap(reset(base, parser)(input('123', ctx))!)], [3, 2, 1]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === undefined);
@@ -26,8 +27,8 @@ describe('Unit: combinator/data/parser/context', () => {
     });
 
     it('node', () => {
-      const base: Context = { resources: { clock: 3, recursions: [1] } };
-      const ctx: Context = { resources: { clock: 2, recursions: [1] } };
+      const base: Opts = { resources: { clock: 3, recursions: [1] } };
+      const ctx: Ctx = new Context({ resources: { clock: 2, recursions: [1] } });
       assert.deepStrictEqual([...unwrap(reset(base, parser)(input('1', ctx))!)], [2]);
       assert(base.resources?.clock === 3);
       assert(ctx.resources?.clock === 1);
@@ -38,15 +39,15 @@ describe('Unit: combinator/data/parser/context', () => {
   });
 
   describe('context', () => {
-    const parser: Parser<boolean, Context & Ctx> = some(creation(1,
+    const parser: Parser<boolean, Ctx & Ctx> = some(creation(1,
       ({ context }) => {
         context.position += 1;
-        return new List([new Data(context.status!)]);
+        return new List([new Node(context.status!)]);
       }));
 
     it('', () => {
-      const base: Context = { status: true };
-      const ctx: Context = { resources: { clock: 2, recursions: [1] } };
+      const base: Opts = { status: true };
+      const ctx: Ctx = new Context({ resources: { clock: 2, recursions: [1] } });
       assert.deepStrictEqual([...unwrap(context(base, parser)(input('1', ctx))!)], [true]);
       assert(base.resources?.clock === undefined);
       assert(ctx.resources?.clock === 1);

package/src/combinator/data/parser/context.ts

@@ -1,9 +1,9 @@
+import { Parser, Result, List, Node, Context, Options } from '../../data/parser';
 import { min } from 'spica/alias';
-import { Parser, Result, List, Data, Ctx, CtxOptions, Node, Context } from '../../data/parser';
 import { clone } from 'spica/assign';
 
-export function reset<P extends Parser>(base: CtxOptions, parser: P): P;
-export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
+export function reset<P extends Parser>(base: Options, parser: P): P;
+export function reset<N>(base: Context, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -13,8 +13,8 @@ export function reset<N>(base: Ctx, parser: Parser<N>): Parser<N> {
     apply(parser, { ...context }, changes, values, true);
 }
 
-export function context<P extends Parser>(base: CtxOptions, parser: P): P;
-export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
+export function context<P extends Parser>(base: Options, parser: P): P;
+export function context<N>(base: Context, parser: Parser<N>): Parser<N> {
   assert(Object.getPrototypeOf(base) === Object.prototype);
   assert(Object.freeze(base));
   const changes = Object.entries(base);
@@ -23,8 +23,8 @@ export function context<N>(base: Ctx, parser: Parser<N>): Parser<N> {
     apply(parser, context, changes, values);
 }
 
-function apply<P extends Parser>(parser: P, context: Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Node<P>>;
-function apply<N>(parser: Parser<N>, context: Ctx, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<N> {
+function apply<P extends Parser>(parser: P, context: Parser.Context<P>, changes: readonly [string, unknown][], values: unknown[], reset?: boolean): Result<Parser.Node<P>>;
+function apply<N>(parser: Parser<N>, context: Context, changes: readonly [string, unknown][], values: unknown[], reset = false): Result<N> {
   for (let i = 0; i < changes.length; ++i) {
     const change = changes[i];
     const prop = change[0];
@@ -36,7 +36,6 @@ function apply<N>(parser: Parser<N>, context: Ctx, changes: readonly [string, un
         assert(reset);
         assert(!context.offset);
         assert(!context.precedence);
-        assert(!context.delimiters);
         assert(!context.state);
         values[i] = context[prop];
         context[prop as string] ??= clone({}, change[1] as object);
@@ -78,7 +77,7 @@ export function creation(cost: number, parser: Parser): Parser {
     return result;
   };
 }
-export function consume(cost: number, context: Ctx): void {
+export function consume(cost: number, context: Context): void {
   const { resources } = context;
   if (!resources) return;
   if (resources.clock < cost) throw new Error('Too many creations');
@@ -107,7 +106,7 @@ export function precedence<N>(precedence: number, parser: Parser<N>): Parser<N>
   assert(precedence >= 0);
   return input => {
     const { context } = input;
-    const { delimiters, precedence: p = 0 } = context;
+    const { delimiters, precedence: p } = context;
     const shift = delimiters && precedence > p;
     context.precedence = precedence;
     // デリミタはシフト後に設定しなければならない
@@ -152,8 +151,8 @@ export function constraint<N>(state: number, positive: boolean | Parser<N>, pars
   return input => {
     const { context } = input;
     const s = positive
-      ? state & context.state!
-      : state & ~context.state!;
+      ? state & context.state
+      : state & ~context.state;
     return s === state
       ? parser(input)
       : undefined;
@@ -173,7 +172,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
         if (advance) {
           context.position += pattern.length;
         }
-        return new List([new Data(pattern)]);
+        return new List([new Node(pattern)]);
       };
     case 'object':
       assert(pattern.sticky);
@@ -186,7 +185,7 @@ export function matcher(pattern: string | RegExp, advance: boolean): Parser<stri
         if (advance) {
           context.position += src.length;
         }
-        return new List([new Data(src)]);
+        return new List([new Node(src)]);
       };
   }
 }

package/src/combinator/data/parser/inits.ts

@@ -1,16 +1,16 @@
-import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Node, Context } from '../parser';
 
-export function inits<P extends Parser>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
+export function inits<P extends Parser>(parsers: Parser.SubParsers<P>, resume?: (nodes: List<Node<Parser.SubNode<P>>>) => boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function inits<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Node<N>>) => boolean): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return input => {
     const { context } = input;
     const { source } = context;
-    let nodes: List<Data<N>> | undefined;
+    let nodes: List<Node<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) break;
-      if (context.delimiters?.match(input)) break;
+      if (context.delimiters.match(input)) break;
       const result = parsers[i](input);
       if (result === undefined) break;
       nodes = nodes?.import(result) ?? result;

package/src/combinator/data/parser/sequence.test.ts

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { sequence } from './sequence';
 import { inspect } from '../../../debug.test';
 
@@ -6,27 +6,26 @@ describe('Unit: combinator/data/parser/sequence', () => {
   describe('sequence', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || new List([new Data('A')])
+        ? void ++context.position || new List([new Node('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || new List([new Data('B')])
+        ? void ++context.position || new List([new Node('B')])
         : undefined;
     };
-    const ab = sequence<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
-    const { context: ctx } = input('', {});
+    const ab = sequence<Parser<string, Context, [typeof a, typeof b]>>([a, b]);
 
     it('basic', () => {
       const parser = ab;
-      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('abb', ctx)), ctx), [['A', 'B'], 'b']);
-      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), undefined);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('b', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ba', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('aab', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('abb', new Context())), [['A', 'B'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('bba', new Context())), undefined);
     });
 
   });

package/src/combinator/data/parser/sequence.ts

@@ -1,16 +1,16 @@
-import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Node, Context } from '../parser';
 
-export function sequence<P extends Parser>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
+export function sequence<P extends Parser>(parsers: Parser.SubParsers<P>, resume?: (nodes: List<Node<Parser.SubNode<P>>>) => boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function sequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Node<N>>) => boolean): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   if (parsers.length === 1) return parsers[0];
   return input => {
     const { context } = input;
     const { source } = context;
-    let nodes: List<Data<N>> | undefined;
+    let nodes: List<Node<N>> | undefined;
     for (let len = parsers.length, i = 0; i < len; ++i) {
       if (context.position === source.length) return;
-      if (context.delimiters?.match(input)) return;
+      if (context.delimiters.match(input)) return;
       const result = parsers[i](input);
       if (result === undefined) return;
       nodes = nodes?.import(result) ?? result;

package/src/combinator/data/parser/some.test.ts

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { union } from './union';
 import { some } from './some';
 import { inspect } from '../../../debug.test';
@@ -7,30 +7,29 @@ describe('Unit: combinator/data/parser/some', () => {
   describe('some', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || new List([new Data('A')])
+        ? void ++context.position || new List([new Node('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || new List([new Data('B')])
+        ? void ++context.position || new List([new Node('B')])
         : undefined;
     };
-    const ab = union<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
-    const { context: ctx } = input('', {});
+    const ab = union<Parser<string, Context, [typeof a, typeof b]>>([a, b]);
 
     it('basic', () => {
       const parser = some(ab, /aaa/y);
-      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), [['B', 'A'], '']);
-      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), [['A', 'A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), [['B', 'B', 'A'], '']);
-      assert.deepStrictEqual(inspect(parser(input('aaa', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('bbb', ctx)), ctx), [['B', 'B', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('aaab', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('baaa', ctx)), ctx), [['B'], 'aaa']);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('b', new Context())), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ba', new Context())), [['B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aab', new Context())), [['A', 'A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('bba', new Context())), [['B', 'B', 'A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aaa', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('bbb', new Context())), [['B', 'B', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('aaab', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('baaa', new Context())), [['B'], 'aaa']);
     });
 
   });

package/src/combinator/data/parser/some.ts

@@ -1,5 +1,5 @@
-import { Parser, List, Data } from '../parser';
-import { Delimiters } from './context/delimiter';
+import { Parser, List, Node } from '../parser';
+import { Delimiters } from '../delimiter';
 
 type DelimiterOption = readonly [delimiter: string | RegExp, precedence: number];
 
@@ -18,22 +18,21 @@ export function some<N>(parser: Parser<N>, end?: string | RegExp | number, delim
     const { context } = input;
     const { source, position } = context;
     //assert(context.backtracks ??= {});
-    let nodes: List<Data<N>> | undefined;
+    let nodes: List<Node<N>> | undefined;
     if (delims.length > 0) {
-      context.delimiters ??= new Delimiters();
       context.delimiters.push(delims);
     }
     // whileは数倍遅い
     for (const len = source.length; context.position < len;) {
       if (match(input)) break;
-      if (context.delimiters?.match(input)) break;
+      if (context.delimiters.match(input)) break;
       const result = parser(input);
       if (result === undefined) break;
       nodes = nodes?.import(result) ?? result;
       if (limit >= 0 && context.position - position > limit) break;
     }
     if (delims.length > 0) {
-      context.delimiters!.pop(delims.length);
+      context.delimiters.pop(delims.length);
     }
     assert(context.position >= position);
     return context.position > position

package/src/combinator/data/parser/subsequence.test.ts

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { subsequence } from './subsequence';
 import { inspect } from '../../../debug.test';
 
@@ -6,35 +6,34 @@ describe('Unit: combinator/data/parser/subsequence', () => {
   describe('subsequence', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || new List([new Data('A')])
+        ? void ++context.position || new List([new Node('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || new List([new Data('B')])
+        ? void ++context.position || new List([new Node('B')])
         : undefined;
     };
     const c: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'c'
-        ? void ++context.position || new List([new Data('C')])
+        ? void ++context.position || new List([new Node('C')])
         : undefined;
     };
-    const abc = subsequence<Parser<string, Ctx, [typeof a, typeof b, typeof c]>>([a, b, c]);
-    const { context: ctx } = input('', {});
+    const abc = subsequence<Parser<string, Context, [typeof a, typeof b, typeof c]>>([a, b, c]);
 
     it('basic', () => {
       const parser = abc;
-      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('c', ctx)), ctx), [['C'], '']);
-      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A', 'B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), [['B'], 'a']);
-      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), [['A'], 'ab']);
-      assert.deepStrictEqual(inspect(parser(input('abb', ctx)), ctx), [['A', 'B'], 'b']);
-      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), [['B'], 'ba']);
-      assert.deepStrictEqual(inspect(parser(input('ac', ctx)), ctx), [['A', 'C'], '']);
-      assert.deepStrictEqual(inspect(parser(input('bc', ctx)), ctx), [['B', 'C'], '']);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('b', new Context())), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('c', new Context())), [['C'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['A', 'B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ba', new Context())), [['B'], 'a']);
+      assert.deepStrictEqual(inspect(parser, input('aab', new Context())), [['A'], 'ab']);
+      assert.deepStrictEqual(inspect(parser, input('abb', new Context())), [['A', 'B'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('bba', new Context())), [['B'], 'ba']);
+      assert.deepStrictEqual(inspect(parser, input('ac', new Context())), [['A', 'C'], '']);
+      assert.deepStrictEqual(inspect(parser, input('bc', new Context())), [['B', 'C'], '']);
     });
 
   });

package/src/combinator/data/parser/subsequence.ts

@@ -1,9 +1,9 @@
-import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Node, Context } from '../parser';
 import { union } from './union';
 import { inits } from './inits';
 
-export function subsequence<P extends Parser>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
+export function subsequence<P extends Parser>(parsers: Parser.SubParsers<P>, resume?: (nodes: List<Node<Parser.SubNode<P>>>) => boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function subsequence<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Node<N>>) => boolean): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   return union(
     parsers.map((_, i) =>

package/src/combinator/data/parser/tails.ts

@@ -1,8 +1,8 @@
-import { Parser, List, Data, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, List, Node, Context } from '../parser';
 import { union } from './union';
 import { sequence } from './sequence';
 
-export function tails<P extends Parser>(parsers: SubParsers<P>, resume?: (nodes: List<Data<SubNode<P>>>) => boolean): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Data<N>>) => boolean): Parser<N, Ctx, D> {
+export function tails<P extends Parser>(parsers: Parser.SubParsers<P>, resume?: (nodes: List<Node<Parser.SubNode<P>>>) => boolean): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function tails<N, D extends Parser<N>[]>(parsers: D, resume?: (nodes: List<Node<N>>) => boolean): Parser<N, Context, D> {
   return union(parsers.map((_, i) => sequence(parsers.slice(i), resume)) as D);
 }

package/src/combinator/data/parser/union.test.ts

@@ -1,4 +1,4 @@
-import { Parser, List, Data, Ctx, input } from '../parser';
+import { Parser, List, Node, Context, input } from '../parser';
 import { union } from './union';
 import { inspect } from '../../../debug.test';
 
@@ -6,27 +6,26 @@ describe('Unit: combinator/data/parser/union', () => {
   describe('union', () => {
     const a: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'a'
-        ? void ++context.position || new List([new Data('A')])
+        ? void ++context.position || new List([new Node('A')])
         : undefined;
     };
     const b: Parser<string> = ({ context }) => {
       return context.source[context.position] === 'b'
-        ? void ++context.position || new List([new Data('B')])
+        ? void ++context.position || new List([new Node('B')])
         : undefined;
     };
-    const ab = union<Parser<string, Ctx, [typeof a, typeof b]>>([a, b]);
-    const { context: ctx } = input('', {});
+    const ab = union<Parser<string, Context, [typeof a, typeof b]>>([a, b]);
 
     it('basic', () => {
       const parser = ab;
-      assert.deepStrictEqual(inspect(parser(input('', ctx)), ctx), undefined);
-      assert.deepStrictEqual(inspect(parser(input('a', ctx)), ctx), [['A'], '']);
-      assert.deepStrictEqual(inspect(parser(input('b', ctx)), ctx), [['B'], '']);
-      assert.deepStrictEqual(inspect(parser(input('ab', ctx)), ctx), [['A'], 'b']);
-      assert.deepStrictEqual(inspect(parser(input('ba', ctx)), ctx), [['B'], 'a']);
-      assert.deepStrictEqual(inspect(parser(input('aab', ctx)), ctx), [['A'], 'ab']);
-      assert.deepStrictEqual(inspect(parser(input('abb', ctx)), ctx), [['A'], 'bb']);
-      assert.deepStrictEqual(inspect(parser(input('bba', ctx)), ctx), [['B'], 'ba']);
+      assert.deepStrictEqual(inspect(parser, input('', new Context())), undefined);
+      assert.deepStrictEqual(inspect(parser, input('a', new Context())), [['A'], '']);
+      assert.deepStrictEqual(inspect(parser, input('b', new Context())), [['B'], '']);
+      assert.deepStrictEqual(inspect(parser, input('ab', new Context())), [['A'], 'b']);
+      assert.deepStrictEqual(inspect(parser, input('ba', new Context())), [['B'], 'a']);
+      assert.deepStrictEqual(inspect(parser, input('aab', new Context())), [['A'], 'ab']);
+      assert.deepStrictEqual(inspect(parser, input('abb', new Context())), [['A'], 'bb']);
+      assert.deepStrictEqual(inspect(parser, input('bba', new Context())), [['B'], 'ba']);
     });
 
   });

package/src/combinator/data/parser/union.ts

@@ -1,7 +1,7 @@
-import { Parser, Ctx, Node, Context, SubParsers, SubNode } from '../parser';
+import { Parser, Context } from '../parser';
 
-export function union<P extends Parser>(parsers: SubParsers<P>): SubNode<P> extends Node<P> ? P : Parser<SubNode<P>, Context<P>, SubParsers<P>>;
-export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Ctx, D> {
+export function union<P extends Parser>(parsers: Parser.SubParsers<P>): Parser.SubNode<P> extends Parser.Node<P> ? P : Parser<Parser.SubNode<P>, Parser.Context<P>, Parser.SubParsers<P>>;
+export function union<N, D extends Parser<N>[]>(parsers: D): Parser<N, Context, D> {
   assert(parsers.every(f => f));
   switch (parsers.length) {
     case 0: