From aad2c4db07803eab5622dfc6188ba5c86383467c Mon Sep 17 00:00:00 2001
From: uzmoi <rizzzse@gmail.com>
Date: Tue, 24 Oct 2023 23:48:13 +0900
Subject: [PATCH] add source type parameter

---
 examples/json.ts         |  6 ++--
 examples/parser-by-do.ts | 38 ++++++++++++-----------
 examples/script.ts       | 27 ++++++++++++-----
 src/combinator.ts        | 34 ++++++++++-----------
 src/context.ts           |  4 +--
 src/do.ts                | 12 ++++----
 src/error.ts             |  6 ++--
 src/parser.ts            | 65 +++++++++++++++++++++++-----------------
 src/primitive.ts         | 30 +++++++++----------
 src/string.ts            | 19 +++++++-----
 10 files changed, 134 insertions(+), 107 deletions(-)

diff --git a/examples/json.ts b/examples/json.ts
index bd0a498..0115c61 100644
--- a/examples/json.ts
+++ b/examples/json.ts
@@ -1,8 +1,8 @@
 import type { JsonValue } from "emnorst";
 import { EOI, choice, el, lazy, literal, many, qo, regex, type Parser } from "../src";
 
-const sepBy = <T>(parser: Parser<T>, sep: Parser) =>
-    qo(perform => {
+const sepBy = <T>(parser: Parser<T, string>, sep: Parser<unknown, string>) =>
+    qo<T[], string>(perform => {
         const head = perform(parser);
         const rest = perform(sep.then(parser).apply(many));
         return [head, ...rest];
@@ -12,7 +12,7 @@ const sepBy = <T>(parser: Parser<T>, sep: Parser) =>
 
 const ws = regex(/[ \n\r\t]*/);
 
-const jsonValue: Parser<JsonValue> = lazy(() =>
+const jsonValue: Parser<JsonValue, string> = lazy(() =>
     choice([
         object,
         array,
diff --git a/examples/parser-by-do.ts b/examples/parser-by-do.ts
index d6b6a58..e805d99 100644
--- a/examples/parser-by-do.ts
+++ b/examples/parser-by-do.ts
@@ -4,50 +4,52 @@ import { qo, type Config, type Parser } from "../src";
 
 const pure = <T>(value: T) => qo(() => value);
 
-const map = <T, U>(parser: Parser<T>, f: (value: T, config: Config) => U) =>
-    qo((perform, config) => f(perform(parser), config));
+const map = <T, U, S>(parser: Parser<T, S>, f: (value: T, config: Config) => U) =>
+    qo<U, S>((perform, config) => f(perform(parser), config));
 
-const flatMap = <T, U>(parser: Parser<T>, f: (value: T, config: Config) => Parser<U>) =>
-    qo((perform, config) => perform(f(perform(parser), config)));
+const flatMap = <T, U, S>(
+    parser: Parser<T, S>,
+    f: (value: T, config: Config) => Parser<U, S>,
+) => qo<U, S>((perform, config) => perform(f(perform(parser), config)));
 
-const and = <T>(left: Parser, right: Parser<T>) =>
-    qo(perform => (perform(left), perform(right)));
+const and = <T, S>(left: Parser<unknown, S>, right: Parser<T, S>) =>
+    qo<T, S>(perform => (perform(left), perform(right)));
 
-const skip = <T>(left: Parser<T>, right: Parser) =>
-    qo(perform => {
+const skip = <T, S>(left: Parser<T, S>, right: Parser<unknown, S>) =>
+    qo<T, S>(perform => {
         const leftValue = perform(left);
         perform(right);
         return leftValue;
     });
 
-const between = <T>(parser: Parser<T>, pre: Parser, post = pre): Parser<T> =>
-    qo(perform => {
+const between = <T, S>(parser: Parser<T, S>, pre: Parser<unknown, S>, post = pre) =>
+    qo<T, S>(perform => {
         perform(pre);
         const value = perform(parser);
         perform(post);
         return value;
     });
 
-const or = <T, U>(left: Parser<T>, right: Parser<U>) =>
-    qo(perform => {
+const or = <T, U, S>(left: Parser<T, S>, right: Parser<U, S>) =>
+    qo<T | U, S>(perform => {
         const leftResult = perform.try(() => ({
             value: perform(left),
         }));
         return leftResult ? leftResult.value : perform(right);
     });
 
-const option = <T, U>(parser: Parser<T>, value: U) =>
-    qo(perform => {
+const option = <T, U, S>(parser: Parser<T, S>, value: U) =>
+    qo<T | U, S>(perform => {
         const result = perform.try(() => ({
             value: perform(parser),
         }));
         return result ? result.value : value;
     });
 
-const seq = <T>(
-    parsers: readonly Parser<T>[],
+const seq = <T, S>(
+    parsers: readonly Parser<T, S>[],
     options?: { allowPartial?: boolean },
-): Parser<T[]> =>
+): Parser<T[], S> =>
     qo(perform => {
         const accum: T[] = [];
         const fullSeq = () => {
@@ -63,7 +65,7 @@ const seq = <T>(
         return accum;
     });
 
-const many = <T>(parser: Parser<T>): Parser<T[]> =>
+const many = <T, S>(parser: Parser<T, S>): Parser<T[], S> =>
     qo(perform => {
         const xs: T[] = [];
         perform.try(() => {
diff --git a/examples/script.ts b/examples/script.ts
index 95e052a..0f1f8c3 100644
--- a/examples/script.ts
+++ b/examples/script.ts
@@ -11,11 +11,14 @@ export type Expr =
     | { type: "Call"; callee: Expr; arguments: readonly Expr[] }
     | { type: "Property"; target: Expr; name: string };
 
-export const expr: P.Parser<Expr> = P.lazy(() =>
+export const expr: P.Parser<Expr, string> = P.lazy(() =>
     P.choice([Bool, Number, String, Tuple, Block, If, Ident]).between(ws).flatMap(tail),
 );
 
-const sepBy = <T>(parser: P.Parser<T>, sep: P.Parser): P.Parser<T[]> => {
+const sepBy = <T, S>(
+    parser: P.Parser<T, S>,
+    sep: P.Parser<unknown, S>,
+): P.Parser<T[], S> => {
     return P.qo(perform => {
         const xs: T[] = [];
         perform.try(() => {
@@ -30,7 +33,7 @@ const sepBy = <T>(parser: P.Parser<T>, sep: P.Parser): P.Parser<T[]> => {
 
 const ws = P.regex(/\s*/);
 
-const keyword = (keyword: string): P.Parser => {
+const keyword = (keyword: string): P.Parser<unknown, string> => {
     return P.literal(keyword).then(P.notFollowedBy(P.regex(/\w/)));
 };
 
@@ -78,7 +81,14 @@ const Break = keyword("break").return<Stat>({ type: "Break" }).skip(ws);
 
 const Expr = expr.map<Stat>(expr => ({ type: "Expr", expr }));
 
-export const stat: P.Parser<Stat> = P.choice([Let, DefFn, Return, While, Break, Expr])
+export const stat: P.Parser<Stat, string> = P.choice([
+    Let,
+    DefFn,
+    Return,
+    While,
+    Break,
+    Expr,
+])
     .skip(P.el(";"))
     .between(ws);
 
@@ -89,7 +99,7 @@ const Bool = P.choice([
 
 const digit = P.oneOf("0123456789");
 const digits = digit.apply(
-    P.manyAccum<string, string>,
+    P.manyAccum<string, string, string>,
     (accum, digit) => accum + digit,
     () => "",
     { min: 1 },
@@ -140,8 +150,11 @@ const If = P.seq([
 const tail = (expr: Expr) =>
     P.choice([Call, Property])
         .skip(ws)
-        .apply(P.many)
-        .map(tails => tails.reduce((expr, tail) => tail(expr), expr));
+        .apply(
+            P.manyAccum<(callee: Expr) => Expr, Expr, string>,
+            (expr, tail) => tail(expr),
+            () => expr,
+        );
 
 const Call = Tuple.map<(callee: Expr) => Expr>(({ elements }) => callee => ({
     type: "Call",
diff --git a/src/combinator.ts b/src/combinator.ts
index b5cf83e..b52205f 100644
--- a/src/combinator.ts
+++ b/src/combinator.ts
@@ -1,13 +1,13 @@
 import { MAX_INT32, clamp } from "emnorst";
 import type { Config } from ".";
-import { Parser, type Parsed } from "./parser";
+import { Parser, type Parsed, type Source } from "./parser";
 import { updateState, type ParseState } from "./state";
 
 /**
  * Delays variable references until the parser runs.
  */
-export const lazy = <T>(getParser: () => Parser<T>): Parser<T> => {
-    let parser: Parser<T>;
+export const lazy = <T, S>(getParser: () => Parser<T, S>): Parser<T, S> => {
+    let parser: Parser<T, S>;
     return new Parser((state, context) => {
         if (parser == null) {
             parser = getParser();
@@ -16,7 +16,7 @@ export const lazy = <T>(getParser: () => Parser<T>): Parser<T> => {
     });
 };
 
-export const notFollowedBy = (parser: Parser): Parser =>
+export const notFollowedBy = <S>(parser: Parser<unknown, S>): Parser<unknown, S> =>
     new Parser((state, context) => {
         const newState = parser.run(state, context);
         if (newState == null) {
@@ -26,7 +26,7 @@ export const notFollowedBy = (parser: Parser): Parser =>
         return null;
     });
 
-export const lookAhead = <T>(parser: Parser<T>): Parser<T> =>
+export const lookAhead = <T, S = unknown>(parser: Parser<T, S>): Parser<T, S> =>
     new Parser((state, context) => {
         const newState = parser.run(state, context);
         return newState && updateState(state, newState.v);
@@ -40,16 +40,16 @@ export const seq: {
     <T extends readonly Parser[] | []>(
         parsers: T,
         options?: { allowPartial?: false },
-    ): Parser<Seq<T>>;
+    ): Parser<Seq<T>, Source<T[number]>>;
     <T extends readonly Parser[] | []>(
         parsers: T,
         options: { allowPartial: boolean },
-    ): Parser<Partial<Seq<T>>>;
+    ): Parser<Partial<Seq<T>>, Source<T[number]>>;
 } = (parsers, options) =>
     new Parser((state, context) => {
         const values: unknown[] = [];
         for (const parser of parsers) {
-            const newState = parser.run(state, context);
+            const newState = parser.run(state, context as never);
             if (newState == null) {
                 if (options?.allowPartial) break;
                 return null;
@@ -59,12 +59,12 @@ export const seq: {
         return updateState(state, values);
     });
 
-type Choice<T extends readonly Parser[]> = Parser<Parsed<T[number]>>;
+type Choice<T extends readonly Parser[]> = Parser<Parsed<T[number]>, Source<T[number]>>;
 
 export const choice = <T extends readonly Parser[] | []>(parsers: T): Choice<T> =>
     new Parser((state, context) => {
         for (const parser of parsers) {
-            const newState = parser.run(state, context);
+            const newState = parser.run(state, context as never);
             if (newState != null) {
                 return newState as ParseState<Parsed<T[number]>>;
             }
@@ -72,12 +72,12 @@ export const choice = <T extends readonly Parser[] | []>(parsers: T): Choice<T>
         return null;
     });
 
-export const manyAccum = <T, U>(
-    parser: Parser<T>,
+export const manyAccum = <T, U, S>(
+    parser: Parser<T, S>,
     f: (accum: U, cur: T, config: Config) => U | void,
     init: (config: Config) => U,
     options?: { min?: number; max?: number },
-): Parser<U> => {
+): Parser<U, S> => {
     const clampedMin = clamp(options?.min || 0, 0, MAX_INT32) | 0;
     const clampedMax = clamp(options?.max || MAX_INT32, clampedMin, MAX_INT32) | 0;
 
@@ -95,11 +95,11 @@ export const manyAccum = <T, U>(
     });
 };
 
-export const many = <T>(
-    parser: Parser<T>,
+export const many = <T, S>(
+    parser: Parser<T, S>,
     options?: { min?: number; max?: number },
-): Parser<T[]> => {
-    return manyAccum<T, T[]>(
+): Parser<T[], S> => {
+    return manyAccum<T, T[], S>(
         parser,
         (array, value) => {
             array.push(value);
diff --git a/src/context.ts b/src/context.ts
index 09319ce..26fda7a 100644
--- a/src/context.ts
+++ b/src/context.ts
@@ -9,8 +9,8 @@ export interface Config {
     readonly [key: string]: unknown;
 }
 
-export class Context {
-    constructor(readonly src: Source, readonly cfg: Config) {
+export class Context<out T = unknown> {
+    constructor(readonly src: ArrayLike<T>, readonly cfg: Config) {
         if (!isArrayLike(src)) {
             throw new TypeError("source is not ArrayLike.");
         }
diff --git a/src/do.ts b/src/do.ts
index ec1ad85..fda2efe 100644
--- a/src/do.ts
+++ b/src/do.ts
@@ -5,14 +5,16 @@ import { updateState } from "./state";
 
 const ParseaDoErrorSymbol = /* #__PURE__ */ Symbol();
 
-interface Perform {
-    <T>(parser: Parser<T>): T;
+export type Perform<S> = {
+    <T>(parser: Parser<T, S>): T;
     try<T>(runner: () => T, allowPartialCommit?: boolean): T | null;
-}
+};
 
-export const qo = <T>(runner: (perform: Perform, config: Config) => T): Parser<T> =>
+export const qo = <T, S>(
+    runner: (perform: Perform<S>, config: Config) => T,
+): Parser<T, S> =>
     new Parser((state, context) => {
-        const perform: Perform = parser => {
+        const perform: Perform<S> = parser => {
             const newState = parser.run(state, context);
             if (newState == null) {
                 throw { [ParseaDoErrorSymbol]: null };
diff --git a/src/error.ts b/src/error.ts
index 98862fd..f85602c 100644
--- a/src/error.ts
+++ b/src/error.ts
@@ -1,10 +1,8 @@
-import type { Source } from "./context";
-
 export type ParseError =
-    | { type: "Expected"; value: Source }
+    | { type: "Expected"; value: ArrayLike<unknown> }
     | { type: "Label"; name: string; length: number };
 
-export const expected = (value: Source): ParseError => ({
+export const expected = (value: ArrayLike<unknown>): ParseError => ({
     type: "Expected",
     value,
 });
diff --git a/src/parser.ts b/src/parser.ts
index 895d7bc..ee0ce81 100644
--- a/src/parser.ts
+++ b/src/parser.ts
@@ -1,32 +1,38 @@
 import { many, manyAccum } from "./combinator";
-import { Context, type Config, type Source } from "./context";
+import { Context, type Config } from "./context";
 import * as error from "./error";
 import { createParseResult, type ParseResult } from "./result";
 import { initState, updateState, type ParseState } from "./state";
 
 export type Parsed<T> = T extends Parser<infer U> ? U : never;
 
-export type ParseRunner<in T, out U> = (
+export type Source<T> = [T] extends [Parser<unknown, infer U>] ? U : never;
+
+export type ParseRunner<in T, out U, in S> = (
     this: void,
     state: ParseState<T>,
-    context: Context,
+    context: Context<S>,
 ) => ParseState<U> | null;
 
-export class Parser<out T = unknown> {
-    constructor(readonly run: ParseRunner<unknown, T>) {}
-    parse(this: Parser<T>, source: Source, config: Config = {}): ParseResult<T> {
+/**
+ * @template T result
+ * @template S source
+ */
+export class Parser<out T = unknown, in S = never> {
+    constructor(readonly run: ParseRunner<unknown, T, S>) {}
+    parse(this: this, source: ArrayLike<S>, config: Config = {}): ParseResult<T> {
         const context = new Context(source, config);
         const finalState = this.run(initState, context);
         return createParseResult(finalState, context);
     }
-    apply<A extends readonly unknown[], R>(
-        this: Parser<T>,
-        f: (parser: Parser<T>, ...args: A) => Parser<R>,
+    apply<A extends readonly unknown[], R, S2>(
+        this: this,
+        f: (parser: Parser<T, S>, ...args: A) => Parser<R, S2>,
         ...args: A
-    ): Parser<R> {
+    ): Parser<R, S2> {
         return f(this, ...args);
     }
-    label(this: Parser<T>, label: string): Parser<T> {
+    label(this: this, label: string): Parser<T, S> {
         return new Parser((state, context) => {
             const labelStart = context.group();
             const newState = this.run(state, context);
@@ -36,52 +42,55 @@ export class Parser<out T = unknown> {
             return newState;
         });
     }
-    return<const U>(this: Parser, value: U): Parser<U> {
+    return<const U>(this: this, value: U): Parser<U, S> {
         return new Parser((state, context) => {
             const newState = this.run(state, context);
             return newState && updateState(newState, value);
         });
     }
-    map<U>(this: Parser<T>, f: (value: T, config: Config) => U): Parser<U> {
+    map<U>(this: this, f: (value: T, config: Config) => U): Parser<U, S> {
         return new Parser((state, context) => {
             const newState = this.run(state, context);
             return newState && updateState(newState, f(newState.v, context.cfg));
         });
     }
-    flatMap<U>(this: Parser<T>, f: (value: T, config: Config) => Parser<U>): Parser<U> {
+    flatMap<U, S2>(
+        this: this,
+        f: (value: T, config: Config) => Parser<U, S2>,
+    ): Parser<U, S & S2> {
         return new Parser((state, context) => {
             const newState = this.run(state, context);
             return newState && f(newState.v, context.cfg).run(newState, context);
         });
     }
-    then<U>(this: Parser, parser: Parser<U>): Parser<U> {
+    then<U, S2>(this: this, parser: Parser<U, S2>): Parser<U, S & S2> {
         return new Parser((state, context) => {
             const newState = this.run(state, context);
             return newState && parser.run(newState, context);
         });
     }
-    skip(this: Parser<T>, parser: Parser): Parser<T> {
+    skip<S2>(this: this, parser: Parser<unknown, S2>): Parser<T, S & S2> {
         return new Parser((state, context) => {
             const newStateA = this.run(state, context);
             const newStateB = newStateA && parser.run(newStateA, context);
             return newStateB && updateState(newStateB, newStateA.v);
         });
     }
-    and<U>(this: Parser<T>, parser: Parser<U>): Parser<[T, U]> {
+    and<U, S2>(this: this, parser: Parser<U, S2>): Parser<[T, U], S & S2> {
         return this.andMap(parser, (a, b) => [a, b]);
     }
-    andMap<U, V>(
-        this: Parser<T>,
-        parser: Parser<U>,
+    andMap<U, V, S2>(
+        this: this,
+        parser: Parser<U, S2>,
         zip: (left: T, right: U) => V,
-    ): Parser<V> {
+    ): Parser<V, S & S2> {
         return new Parser((state, context) => {
             const newStateA = this.run(state, context);
             const newStateB = newStateA && parser.run(newStateA, context);
             return newStateB && updateState(newStateB, zip(newStateA.v, newStateB.v));
         });
     }
-    between<T>(this: Parser<T>, pre: Parser, post = pre): Parser<T> {
+    between<S2>(this: this, pre: Parser<unknown, S2>, post = pre): Parser<T, S & S2> {
         return new Parser((state, context) => {
             const newStateA = pre.run(state, context);
             const newStateB = newStateA && this.run(newStateA, context);
@@ -89,15 +98,15 @@ export class Parser<out T = unknown> {
             return newStateC && updateState(newStateC, newStateB.v);
         });
     }
-    or<U>(this: Parser<T>, parser: Parser<U>): Parser<T | U> {
-        return new Parser<T | U>((state, context) => {
+    or<U, S2>(this: this, parser: Parser<U, S2>): Parser<T | U, S & S2> {
+        return new Parser<T | U, S & S2>((state, context) => {
             return this.run(state, context) ?? parser.run(state, context);
         });
     }
-    option(this: Parser<T>): Parser<T | undefined>;
-    option<const U>(this: Parser<T>, value: U): Parser<T | U>;
-    option<U>(this: Parser<T>, value?: U): Parser<T | U> {
-        return new Parser<T | U>((state, context) => {
+    option(this: this): Parser<T | undefined, S>;
+    option<const U>(this: this, value: U): Parser<T | U, S>;
+    option<U>(this: this, value?: U): Parser<T | U, S> {
+        return new Parser<T | U, S>((state, context) => {
             return this.run(state, context) ?? updateState(state, value as U);
         });
     }
diff --git a/src/primitive.ts b/src/primitive.ts
index 8ef2860..22ea391 100644
--- a/src/primitive.ts
+++ b/src/primitive.ts
@@ -1,5 +1,5 @@
 import { equals } from "emnorst";
-import type { Config, Source } from "./context";
+import type { Config } from "./context";
 import * as error from "./error";
 import { Parser } from "./parser";
 import { updateState } from "./state";
@@ -7,10 +7,10 @@ import { updateState } from "./state";
 /**
  * Always succeed with the value of the argument.
  */
-export const pure = <const T>(value: T): Parser<T> =>
+export const pure = <const T>(value: T): Parser<T, unknown> =>
     new Parser(state => updateState(state, value));
 
-export const fail = (): Parser<never> =>
+export const fail = (): Parser<never, unknown> =>
     new Parser((state, context) => {
         context.addError(state.i);
         return null;
@@ -19,7 +19,7 @@ export const fail = (): Parser<never> =>
 /**
  * end of input
  */
-export const EOI = /* #__PURE__ */ new Parser((state, context) => {
+export const EOI = /* #__PURE__ */ new Parser<unknown, unknown>((state, context) => {
     if (state.i < context.src.length) {
         context.addError(state.i);
         return null;
@@ -33,7 +33,7 @@ export const EOI = /* #__PURE__ */ new Parser((state, context) => {
  * @example any.parse([someValue]).value === someValue;
  * @example any.parse([]); // parse fail
  */
-export const ANY_EL = /* #__PURE__ */ new Parser((state, context) => {
+export const ANY_EL = /* #__PURE__ */ new Parser<unknown, unknown>((state, context) => {
     if (state.i < context.src.length) {
         return updateState(state, context.src[state.i], 1);
     }
@@ -41,42 +41,42 @@ export const ANY_EL = /* #__PURE__ */ new Parser((state, context) => {
     return null;
 });
 
-export const el = <const T>(value: T): Parser<T> =>
+export const el = <const T>(value: T): Parser<T, unknown> =>
     satisfy(srcEl => equals(srcEl, value), {
         error: error.expected(
             typeof value === "string" && value.length === 1 ? value : [value],
         ),
     });
 
-export const oneOf = <const T>(values: Iterable<T>): Parser<T> => {
+export const oneOf = <const T>(values: Iterable<T>): Parser<T, unknown> => {
     const set = new Set<unknown>(values);
     return satisfy(el => set.has(el));
 };
 
-export const noneOf = (values: Iterable<unknown>): Parser => {
+export const noneOf = (values: Iterable<unknown>): Parser<unknown, unknown> => {
     const set = new Set(values);
     return satisfy(el => !set.has(el));
 };
 
-export const satisfy = <T>(
-    f:
-        | ((el: unknown, config: Config) => boolean)
-        | ((el: unknown, config: Config) => el is T),
+export const satisfy = <T extends S, S = unknown>(
+    f: ((el: S, config: Config) => boolean) | ((el: S, config: Config) => el is T),
     options?: { error?: error.ParseError },
-): Parser<T> =>
+): Parser<T, S> =>
     new Parser((state, context) => {
         let srcEl: unknown;
         if (
             state.i < context.src.length &&
             f((srcEl = context.src[state.i]), context.cfg)
         ) {
-            return updateState(state, srcEl, 1);
+            return updateState(state, srcEl as T, 1);
         }
         context.addError(state.i, options?.error);
         return null;
     });
 
-export const literal = <const T extends Source>(chunk: T): Parser<T> =>
+export const literal = <const T extends ArrayLike<unknown>>(
+    chunk: T,
+): Parser<T, unknown> =>
     new Parser((state, context) => {
         if (state.i + chunk.length > context.src.length) {
             context.addError(state.i, error.expected(chunk));
diff --git a/src/string.ts b/src/string.ts
index 78615cc..612c97e 100644
--- a/src/string.ts
+++ b/src/string.ts
@@ -2,7 +2,7 @@ import * as error from "./error";
 import { Parser } from "./parser";
 import { updateState } from "./state";
 
-export const string = <const T extends string>(string: T): Parser<T> => {
+export const string = <const T extends string>(string: T): Parser<T, string> => {
     return new Parser((state, context) => {
         if (typeof context.src !== "string") {
             context.addError(state.i);
@@ -19,7 +19,7 @@ export const string = <const T extends string>(string: T): Parser<T> => {
 
 const graphemeSegmenter = /* @__PURE__ */ new Intl.Segmenter();
 
-export const graphemeString = (string: string): Parser<string> => {
+export const graphemeString = (string: string): Parser<string, string> => {
     const normalizedString = string.normalize();
     return new Parser((state, context) => {
         if (typeof context.src !== "string") {
@@ -60,7 +60,7 @@ export const graphemeString = (string: string): Parser<string> => {
     });
 };
 
-export const CODE_POINT = /* @__PURE__ */ new Parser((state, context) => {
+export const CODE_POINT = /* @__PURE__ */ new Parser<string, string>((state, context) => {
     if (typeof context.src !== "string") {
         context.addError(state.i);
         return null;
@@ -92,7 +92,7 @@ export const CODE_POINT = /* @__PURE__ */ new Parser((state, context) => {
     return updateState(state, context.src[state.i], 1);
 });
 
-export const ANY_CHAR = /* @__PURE__ */ new Parser((state, context) => {
+export const ANY_CHAR = /* @__PURE__ */ new Parser<string, string>((state, context) => {
     if (typeof context.src !== "string") {
         context.addError(state.i);
         return null;
@@ -109,7 +109,7 @@ export const ANY_CHAR = /* @__PURE__ */ new Parser((state, context) => {
     return updateState(state, segmentData.segment, segmentData.segment.length);
 });
 
-export const regexGroup = (re: RegExp): Parser<RegExpExecArray> => {
+export const regexGroup = (re: RegExp): Parser<RegExpExecArray, string> => {
     const fixedRegex = new RegExp(`^(?:${re.source})`, re.flags.replace("g", ""));
 
     return new Parser((state, context) => {
@@ -127,9 +127,12 @@ export const regexGroup = (re: RegExp): Parser<RegExpExecArray> => {
 };
 
 export const regex: {
-    (re: RegExp): Parser<string>;
-    (re: RegExp, groupId: number | string): Parser<string | undefined>;
-    <T>(re: RegExp, groupId: number | string, defaultValue: T): Parser<string | T>;
+    (re: RegExp): Parser<string, string>;
+    (re: RegExp, groupId: number | string): Parser<string | undefined, string>;
+    <T>(re: RegExp, groupId: number | string, defaultValue: T): Parser<
+        string | T,
+        string
+    >;
 } = (re: RegExp, groupId: number | string = 0, defaultValue?: undefined) =>
     regexGroup(re).map(
         matchResult =>