fix: codestyle

Author: verytactical

packages/pgen/compile.ts

@@ -220,7 +220,7 @@ const compileTerminal = (node: g.Terminal): Compiler<ExprWithType> => ctx => {
     return ewt(emitCall('str', [wrapped]), t.tsLiteralType(t.stringLiteral(value)));
 };
 
-const compileClass = ({ insensitive, negated, seqs }: g.Class): Compiler<ExprWithType> => ctx => {
+const compileClass = ({ negated, seqs }: g.Class): Compiler<ExprWithType> => ctx => {
     const prefix = negated ? "^" : "";
     const children = seqs.map(seq => compileSeq(seq));
     const body = children.map(child => child.expr).join('');
@@ -234,7 +234,6 @@ const compileClass = ({ insensitive, negated, seqs }: g.Class): Compiler<ExprWit
                 negated
                     ? emitCall('negateExps', [expectables])
                     : expectables,
-                // t.booleanLiteral(insensitive)
             ],
             [t.tsUnionType(types)]
         ),

packages/pgen/index.ts

@@ -19,22 +19,6 @@ const main = async () => {
 
     const code = await fs.readFile(source, 'utf-8');
 
-    // const ident = (
-    //     (
-    //         $.regex<string | "_">("a-z_", [$.ExpRange("a", "z"), $.ExpString("_")]),
-    //         // $.right(
-    //         //     $.regex<string | "_">("a-z_", [$.ExpRange("a", "z"), $.ExpString("_")]),
-    //         //     $.right(
-    //         //         $.star(
-    //         //             $.regex<string | string | "_">(
-    //         //                 "a-z0-9_", [$.ExpRange("a", "z"), $.ExpRange("0", "9"), $.ExpString("_")]
-    //         //             )
-    //         //         ), 
-    //         //         $.eps
-    //         //     )
-    //         // )
-    //     )
-    // );
     const ast = $.parse($.compile(G.Grammar, G.space))(code);
     if (ast.$ === 'error') {
         console.error(ast.error);

packages/pgen/runtime.ts

@@ -173,8 +173,8 @@ export const sat = (cond: (c: string) => boolean, message: string): Parser<strin
     return ctx.assert(ctx.p < ctx.l && cond(c), message, 1, c);
 };
 
-export const regex = <K = string>(s: string, insensitive: boolean = false): Parser<K> => {
-    const r = new RegExp(`^[${s}]$`, insensitive ? "i" : undefined);
+export const regex = <K = string>(s: string): Parser<K> => {
+    const r = new RegExp(`^[${s}]$`);
     return sat(c => r.test(c), `[${s}]`) as Parser<K>;
 };
 

packages/pgen/transform.ts

@@ -64,8 +64,8 @@ export type Optional = { readonly $: 'Optional', readonly expr: Expr }
 export const Optional = (expr: Expr): Optional => ({ $: "Optional", expr });
 export type Call = { readonly $: "Call", readonly name: string, readonly params: readonly Expr[] }
 export const Call = (name: string, params: readonly Expr[]): Call => ({ $: "Call", name, params });
-export type Class = { readonly $: "Class", readonly seqs: readonly (Group | ClassChar | SpecialClass | Escape)[], readonly negated: boolean, readonly insensitive: boolean }
-export const Class = (seqs: readonly (Group | ClassChar | SpecialClass | Escape)[], negated: boolean, insensitive: boolean): Class => ({ $: "Class", insensitive, negated, seqs });
+export type Class = { readonly $: "Class", readonly seqs: readonly (Group | ClassChar | SpecialClass | Escape)[], readonly negated: boolean }
+export const Class = (seqs: readonly (Group | ClassChar | SpecialClass | Escape)[], negated: boolean): Class => ({ $: "Class", negated, seqs });
 export type Group = { readonly $: "Group", readonly from: ClassChar | SpecialClass | Escape, readonly to: ClassChar | SpecialClass | Escape }
 export const Group = (from: ClassChar | SpecialClass | Escape, to: ClassChar | SpecialClass | Escape): Group => ({ $: "Group", from, to });
 export type ClassChar = { readonly $: "ClassChar", readonly value: string }
@@ -89,11 +89,6 @@ export const Long = (value: string): Long => ({ $: "Long", value });
 export type Ascii = { readonly $: "Ascii", readonly value: string }
 export const Ascii = (value: string): Ascii => ({ $: "Ascii", value });
 
-type SkipType =
-    | 'no-space' // no space rule
-    | 'skip-space' // has space rule, compile with skipping
-    | 'keep-space' // has space rule, compile without skipping
-
 type Context = {
     formals: Set<string>;
 }
@@ -205,7 +200,7 @@ const transformAny = (_node: g.Any): Transform<Expr> => () => {
 };
 
 const transformClass = ({ negated, seqs }: g.Class): Transform<Expr> => () => {
-    return Class(seqs, negated === '^', false);
+    return Class(seqs, negated === '^');
 };
 
 const transformTerminal = ({ value }: g.Terminal): Transform<Expr> => () => {

packages/runtime/lib/located.d.ts

@@ -5,7 +5,7 @@ export type Parser<T> = P.Parser<readonly [T, L.Loc]>;
 export declare const any: Parser<string>;
 export declare const range: (from: string, to: string) => Parser<string>;
 export declare const str: <K extends string>(s: K) => Parser<K>;
-export declare const regex: <K = string>(s: string, exps: Expectable[], insensitive?: boolean) => Parser<K>;
+export declare const regex: <K = string>(s: string, exps: Expectable[]) => Parser<K>;
 export declare const app: <A, B>(child: Parser<A>, f: (a: A) => B) => Parser<B>;
 export declare const seq: <T, U>(left: Parser<T>, right: Parser<U>) => Parser<[T, U]>;
 export declare const alt: <T, U>(left: Parser<T>, right: Parser<U>) => Parser<T | U>;

packages/runtime/lib/located.d.ts.map

@@ -56,13 +56,10 @@ const str = (s) => {
     return terminal(P.str(s));
 };
 exports.str = str;
-const regex = (s, exps, insensitive = false) => {
-    return terminal(P.regex(s, exps, insensitive));
+const regex = (s, exps) => {
+    return terminal(P.regex(s, exps));
 };
 exports.regex = regex;
-// export const pure = <const T>(t: T): Parser<T> => ctx => {
-//     return P.app(P.pure(t), t => [t, L.emptyLoc(ctx.p)] as const)(ctx);
-// };
 const app = (child, f) => {
     return P.app(child, ([v, l]) => [f(v), l]);
 };

packages/runtime/lib/located.js

@@ -25,7 +25,7 @@ export type GetResult<T> = T extends Parser<infer T> ? T : never;
 export declare const terminal: <T>(kind: E.Expectable, child: (ctx: Context) => Result<T>) => Parser<T>;
 export declare const any: Parser<string>;
 export declare const range: (from: string, to: string) => Parser<string>;
-export declare const regex: <K = string>(s: string, exps: E.Expectable[], insensitive?: boolean) => Parser<K>;
+export declare const regex: <K = string>(s: string, exps: E.Expectable[]) => Parser<K>;
 export declare const str: <K extends string>(s: K) => Parser<K>;
 export declare const app: <A, B>(child: Parser<A>, f: (a: A) => B) => Parser<B>;
 export declare const seq: <T, U>(left: Parser<T>, right: Parser<U>) => Parser<[T, U]>;

packages/runtime/lib/runtime.d.ts

@@ -77,8 +77,8 @@ const range = (from, to) => (0, exports.terminal)(E.ExpRange(from, to), ctx => {
     }
 });
 exports.range = range;
-const regex = (s, exps, insensitive = false) => {
-    const r = new RegExp(`^[${s}]$`, insensitive ? "i" : undefined);
+const regex = (s, exps) => {
+    const r = new RegExp(`^[${s}]$`);
     return ctx => {
         const at = ctx.p;
         const c = ctx.s[at];
@@ -103,7 +103,6 @@ const str = (s) => (0, exports.terminal)(E.ExpString(s), ctx => {
     }
 });
 exports.str = str;
-// export const pure = <const T>(t: T): Parser<T> => () => success(t);
 const app = (child, f) => ctx => {
     const r = child(ctx);
     return {