crazy-parser/src/index.d.ts

A light-weight parser combinator

export declare const Nothing: unique symbol;
export type State = {
    index: number;
};
type Vector<A, Count extends number, TmpResult extends Array<A> = []> = TmpResult["length"] extends Count ? TmpResult : Vector<A, Count, [A, ...TmpResult]>;
export declare class Parser<A, E extends Error = Error> {
    readonly f: (input: Uint32Array, state: State) => A | E;
    constructor(f: (input: Uint32Array, state: State) => A | E);
    cmap<B>(c: B): Parser<B, E>;
    map<B>(f: (a: A) => B): Parser<B, E>;
    or<B, E2 extends Error>(p: Parser<B, E2>): Parser<A | B, E2>;
    orPure<B>(c: B): Parser<A | B, any>;
    bind<B, E2 extends Error>(gf: (a: A) => Parser<B, E2>): Parser<B, E | E2>;
    and<B, E2 extends Error>(p: Parser<B, E2>): Parser<[A, B], E | E2>;
    left<B, E2 extends Error>(p: Parser<B, E2>): Parser<A, E | E2>;
    right<B, E2 extends Error>(p: Parser<B, E2>): Parser<B, E | E2>;
    many(): Parser<Array<A>, E>;
    some(): Parser<Array<A>, E>;
    _$_<B, E2 extends Error>(p: Parser<B, E2>): Parser<[A, B], E | E2>;
    _$<B, E2 extends Error>(p: Parser<B, E2>): Parser<A, E | E2>;
    $_<B, E2 extends Error>(p: Parser<B, E2>): Parser<B, E | E2>;
    if(c: boolean): Parser<A>;
    where<E2 extends Error = Error>(c: (a: A) => boolean, e2?: E2): Parser<A, E | E2>;
    optional(): Parser<A | typeof Nothing, E>;
    x<N extends number>(n: N): Parser<Vector<A, N>, E>;
    withRange(): Parser<[A, [number, number]], E>;
    try(): Parser<A, E>;
    error<E2 extends Error>(e: E2): Parser<A, E2>;
    run(input: string): [A | E, State];
    eval(input: string): A | E;
    runPromise(input: string): Promise<[A, State]>;
    evalPromise(input: string): Promise<A>;
    trace(...message: Array<any>): Parser<A, E>;
}
export declare function pure<A>(c: A): Parser<A, any>;
export declare const empty: Parser<any>;
export declare function asum<A>(...args: [Array<Parser<A, any>>]): Parser<A>;
export declare function asum<A>(...args: Array<Parser<A, any>>): Parser<A>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error>(args: [Parser<A1, E1>, Parser<A2, E2>]): Parser<[A1, A2], E1 | E2>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error>(args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>
]): Parser<[A1, A2, A3], E1 | E2 | E3>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error, A4, E4 extends Error>(args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>,
    Parser<A4, E4>
]): Parser<[A1, A2, A3, A4], E1 | E2 | E3 | E4>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error, A4, E4 extends Error, A5, E5 extends Error>(args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>,
    Parser<A4, E4>,
    Parser<A5, E5>
]): Parser<[A1, A2, A3, A4, A5], E1 | E2 | E3 | E4 | E5>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error, A4, E4 extends Error, A5, E5 extends Error, A6, E6 extends Error>(args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>,
    Parser<A4, E4>,
    Parser<A5, E5>,
    Parser<A6, E6>
]): Parser<[A1, A2, A3, A4, A5, A6], E1 | E2 | E3 | E4 | E5 | E6>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error>(...args: [Parser<A1, E1>, Parser<A2, E2>]): Parser<[A1, A2], E1 | E2>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error>(...args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>
]): Parser<[A1, A2, A3], E1 | E2 | E3>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error, A4, E4 extends Error>(...args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>,
    Parser<A4, E4>
]): Parser<[A1, A2, A3, A4], E1 | E2 | E3 | E4>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error, A4, E4 extends Error, A5, E5 extends Error>(...args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>,
    Parser<A4, E4>,
    Parser<A5, E5>
]): Parser<[A1, A2, A3, A4, A5], E1 | E2 | E3 | E4 | E5>;
export declare function sequence<A1, E1 extends Error, A2, E2 extends Error, A3, E3 extends Error, A4, E4 extends Error, A5, E5 extends Error, A6, E6 extends Error>(...args: [
    Parser<A1, E1>,
    Parser<A2, E2>,
    Parser<A3, E3>,
    Parser<A4, E4>,
    Parser<A5, E5>,
    Parser<A6, E6>
]): Parser<[A1, A2, A3, A4, A5, A6], E1 | E2 | E3 | E4 | E5 | E6>;
export declare function sequence<Ts extends Array<[any, Error]>>(ps: {
    [I in keyof Ts]: Parser<Ts[I][0], Ts[I][1]>;
}): Parser<{
    [I in keyof Ts]: Ts[I][0];
}, Ts[number][1]>;
export declare function sequence<Ts extends Array<[any, Error]>>(...ps: {
    [I in keyof Ts]: Parser<Ts[I][0], Ts[I][1]>;
}): Parser<{
    [I in keyof Ts]: Ts[I][0];
}, Ts[number][1]>;
export declare const eof: Parser<unknown, Error>;
export declare const one: Parser<string, Error>;
export declare function char<C extends string>(c: C): Parser<C>;
export declare const digit: Parser<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9">;
export declare const upper: Parser<"A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z">;
export declare const lower: Parser<"a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z">;
export declare const hex: Parser<"0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "A" | "B" | "C" | "D" | "E" | "F" | "a" | "b" | "c" | "d" | "e" | "f">;
export declare const alpha: Parser<"Q" | "d" | "r" | "x" | "y" | "a" | "b" | "i" | "p" | "q" | "s" | "u" | "g" | "f" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "c" | "e" | "h" | "j" | "k" | "l" | "m" | "n" | "o" | "t" | "v" | "w" | "z", Error>;
export declare const space: Parser<" ", Error>;
export declare const tab: Parser<"\t", Error>;
export declare const cr: Parser<"\r", Error>;
export declare const lf: Parser<"\n", Error>;
export declare const index: Parser<number, any>;
export declare function str<S extends string>(s: S): Parser<S>;
export declare function span(f: (c: string) => boolean): Parser<Array<string>, any>;
export declare function anyChar<Cs extends Array<string>>(cs: Cs): Parser<Cs[number]>;
export declare function anyStr<Ss extends Array<string>>(ss: Ss): Parser<Ss[number]>;
export declare function lazy<P extends Parser<any, any>>(pg: () => P): P;
export declare function template<Ts extends Array<[any, any]>>(ss: TemplateStringsArray, ...ps: {
    [I in keyof Ts]: Parser<Ts[I][0], Ts[I][1]>;
}): Parser<{
    [I in keyof Ts]: Ts[I][0];
}, Ts[number][1]>;
export {};