yukigo-haskell-parser 0.1.2 → 0.2.1

package/src/index.ts

@@ -1,192 +1,223 @@
-import grammar from "./parser/grammar.js";
-import nearley from "nearley";
-import { groupFunctionDeclarations } from "./utils/helpers.js";
-import { TypeChecker } from "./typechecker/checker.js";
-import {
-  ArithmeticUnaryOperation,
-  AST,
-  Equation,
-  Expression,
-  Function,
-  Instance,
-  ListType,
-  Return,
-  Sequence,
-  SimpleType,
-  StringOperation,
-  StringPrimitive,
-  SymbolPrimitive,
-  TypePattern,
-  UnguardedBody,
-  VariablePattern,
-  YukigoParser,
-} from "yukigo-ast";
-import { preludeCode } from "./prelude.js";
-import { typeMappings } from "./utils/types.js";
-import { Token } from "moo";
-
-class UnexpectedToken extends Error {
-  constructor(token: Token) {
-    super(
-      `Parser: Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`,
-    );
-  }
-}
-class AmbiguityError extends Error {
-  constructor(amountAST: number) {
-    super(
-      `Parser: Too much ambiguity. ${amountAST} ASTs parsed. Output not generated.`,
-    );
-  }
-}
-class TypeError extends Error {
-  constructor(errors: string[]) {
-    super(`Found type errors.\n\t-${errors.join("\n\t-")}`);
-  }
-}
-
-export type HaskellConfig = {
-  typecheck: boolean;
-  includePrims: boolean;
-};
-
-const HaskellDefaultConfig = {
-  typecheck: true,
-  includePrims: true,
-};
-
-export class YukigoHaskellParser implements YukigoParser {
-  public errors: string[] = [];
-  private prelude: AST;
-  private config: HaskellConfig;
-  private checker?: TypeChecker;
-
-  constructor(
-    prelude: string = preludeCode,
-    config: HaskellConfig = HaskellDefaultConfig,
-  ) {
-    this.errors = [];
-    this.prelude = this.feedParser(prelude);
-    this.config = config;
-  }
-
-  private preprocessor(code: string): string {
-    return code.replace(/Exception\.evaluate/g, "evaluate");
-  }
-
-  public parse(code: string): AST {
-    const processedCode = this.preprocessor(code);
-    const result = this.feedParser(processedCode);
-    const fullAst = this.prelude.concat(result);
-
-    const makePrim = (name: string) => new Function(new SymbolPrimitive(name), [
-      new Equation(
-        [new VariablePattern(new SymbolPrimitive("x"))],
-        new UnguardedBody(new Sequence([new Return(new ArithmeticUnaryOperation("ToString", new SymbolPrimitive("x")))]))
-      )
-    ]);
-
-    const prims = [
-      makePrim("primShow"),
-      makePrim("primShowChar"), 
-      makePrim("primShowString"),
-      makePrim("primShowList")
-    ];
-
-    const resolveYukigoType = (t: any): any => {
-      if (t instanceof SimpleType) {
-        const mapped = typeMappings[t.value];
-        if (mapped) return new SimpleType(mapped, t.constraints, t.loc);
-        return t;
-      }
-      if (t instanceof ListType) return t;
-      return t;
-    };
-
-    const primShowString = new Function(new SymbolPrimitive("primShowString"), [
-      new Equation(
-        [new VariablePattern(new SymbolPrimitive("s"))],
-        new UnguardedBody(new Sequence([
-          new Return(
-            new StringOperation(
-              "Concat", 
-              new StringPrimitive("\""),
-              new StringOperation("Concat", new SymbolPrimitive("s"), new StringPrimitive("\""))
-            )
-          )
-        ]))
-      )
-    ]);
-
-    // Transform Instance nodes into Function nodes with TypePatterns
-    const transformedAst: AST = this.config.includePrims ? [...prims, primShowString] : [];
-    for (const node of fullAst) {
-      if (node instanceof Instance) {
-        const instanceNode = node as Instance;
-        const yukigoType = resolveYukigoType(instanceNode.type);
-
-        for (const func of instanceNode.functions) {
-          const overloadedEquations = func.equations.map((eq) => {
-            const firstPattern = eq.patterns[0];
-            const typePattern = new TypePattern(
-              yukigoType,
-              firstPattern
-            );
-            return new Equation(
-              [typePattern, ...eq.patterns.slice(1)],
-              eq.body,
-              eq.returnExpr,
-              eq.loc
-            );
-          });
-          transformedAst.unshift(
-            new Function(func.identifier, overloadedEquations, func.loc)
-          );
-        }
-      } else {
-        transformedAst.push(node);
-      }
-    }
-
-    const ast = groupFunctionDeclarations(transformedAst);
-    if (this.config.typecheck) {
-      this.checker = new TypeChecker();
-      const errors = this.checker.check(ast);
-      if (errors.length > 0) {
-        this.errors.push(...errors);
-        throw new TypeError(errors);
-      }
-    }
-    return ast;
-  }
-  public parseExpression(code: string): Expression {
-    const processedCode = this.preprocessor(code);
-    const expr = this.feedParser(processedCode)[0];
-    return expr;
-  }
-  private feedParser(code: string): any {
-    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
-    try {
-      parser.feed(code);
-      parser.finish();
-    } catch (error) {
-      if ("token" in error && error.token) throw new UnexpectedToken(error.token);
-      throw error;
-    }
-    const { results } = parser;
-    if (results.length > 1) throw new AmbiguityError(results.length);
-    if (results.length == 0) return [];
-    return results[0];
-  }
-  public typeOfExpression(code: string): string {
-    if (!this.config.typecheck || !this.checker)
-      throw new Error("Type checking not initialized. Did you load a file?");
-
-    const expr = this.parseExpression(code);
-    return this.checker.inferExpression(expr);
-  }
-  public getKnownSymbols(): string[] {
-    if (!this.config.typecheck || !this.checker) return [];
-    return this.checker.getKnownSymbols();
-  }
-}
+import grammar from "./parser/grammar.cjs";
+import nearley from "nearley";
+import { groupFunctionDeclarations } from "./utils/helpers.js";
+import { TypeChecker } from "./typechecker/checker.js";
+import {
+  ArithmeticUnaryOperation,
+  AST,
+  Equation,
+  Expression,
+  Function,
+  Instance,
+  ListType,
+  Return,
+  Sequence,
+  SimpleType,
+  StringOperation,
+  StringPrimitive,
+  SymbolPrimitive,
+  TypePattern,
+  UnguardedBody,
+  VariablePattern,
+  YukigoParser,
+} from "yukigo-ast";
+import { preludeCode } from "./prelude.js";
+import { typeMappings } from "./utils/types.js";
+import { Token } from "moo";
+
+interface NearleyError {
+  token?: any;
+  offset?: number;
+  [key: string]: any;
+}
+
+class UnexpectedToken extends Error {
+  constructor(token: Token) {
+    super(
+      `Parser: Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`,
+    );
+  }
+}
+class AmbiguityError extends Error {
+  constructor(amountAST: number) {
+    super(
+      `Parser: Too much ambiguity. ${amountAST} ASTs parsed. Output not generated.`,
+    );
+  }
+}
+class TypeError extends Error {
+  constructor(errors: string[]) {
+    super(`Found type errors.\n\t-${errors.join("\n\t-")}`);
+  }
+}
+
+export type HaskellConfig = {
+  typecheck: boolean;
+  includePrims: boolean;
+};
+
+const HaskellDefaultConfig = {
+  typecheck: true,
+  includePrims: true,
+};
+
+export class YukigoHaskellParser implements YukigoParser {
+  public errors: string[] = [];
+  private prelude: AST;
+  private config: HaskellConfig;
+  private checker?: TypeChecker;
+
+  constructor(
+    prelude: string = preludeCode,
+    config: HaskellConfig = HaskellDefaultConfig,
+  ) {
+    this.errors = [];
+    this.prelude = this.feedParser(prelude);
+    this.config = config;
+  }
+
+  private preprocessor(code: string): string {
+    return code.replace(/Exception\.evaluate/g, "evaluate");
+  }
+
+  public parse(code: string): AST {
+    const processedCode = this.preprocessor(code);
+    const result = this.feedParser(processedCode);
+    const fullAst = this.prelude.concat(result);
+
+    const makePrim = (name: string) => {
+      const returnExpr = new Return(
+        new ArithmeticUnaryOperation(
+          "ToString",
+          new SymbolPrimitive("x"),
+        ),
+      );
+      return new Function(new SymbolPrimitive(name), [
+        new Equation(
+          [new VariablePattern(new SymbolPrimitive("x"))],
+          new UnguardedBody(
+            new Sequence([returnExpr]),
+          ),
+          returnExpr,
+        ),
+      ]);
+    };
+
+    const prims = [
+      makePrim("primShow"),
+      makePrim("primShowChar"),
+      makePrim("primShowString"),
+      makePrim("primShowList"),
+    ];
+
+    const resolveYukigoType = (t: any): any => {
+      if (t instanceof SimpleType) {
+        const mapped = typeMappings[t.value];
+        if (mapped) {
+          const runtimeTypeName = mapped.replace(/^Yu/, "");
+          return new SimpleType(runtimeTypeName, t.constraints, t.loc);
+        }
+        return t;
+      }
+      if (t instanceof ListType) return t;
+      return t;
+    };
+
+    const primShowStringReturnExpr = new Return(
+      new StringOperation(
+        "Concat",
+        new StringPrimitive('"'),
+        new StringOperation(
+          "Concat",
+          new SymbolPrimitive("s"),
+          new StringPrimitive('"'),
+        ),
+      ),
+    );
+
+    const primShowString = new Function(new SymbolPrimitive("primShowString"), [
+      new Equation(
+        [new VariablePattern(new SymbolPrimitive("s"))],
+        new UnguardedBody(
+          new Sequence([primShowStringReturnExpr]),
+        ),
+        primShowStringReturnExpr,
+      ),
+    ]);
+
+    // Transform Instance nodes into Function nodes with TypePatterns
+    const transformedAst: AST = this.config.includePrims
+      ? [...prims, primShowString]
+      : [];
+    for (const node of fullAst) {
+      if (node instanceof Instance) {
+        const instanceNode = node as Instance;
+        const yukigoType = resolveYukigoType(instanceNode.type);
+
+        for (const func of instanceNode.functions) {
+          const overloadedEquations = func.equations.map((eq) => {
+            const firstPattern = eq.patterns[0];
+            const typePattern = new TypePattern(yukigoType, firstPattern);
+            return new Equation(
+              [typePattern, ...eq.patterns.slice(1)],
+              eq.body,
+              eq.returnExpr,
+              eq.loc,
+            );
+          });
+          transformedAst.unshift(
+            new Function(func.identifier, overloadedEquations, func.loc),
+          );
+        }
+      } else {
+        transformedAst.push(node);
+      }
+    }
+
+    const ast = groupFunctionDeclarations(transformedAst);
+    if (this.config.typecheck) {
+      this.checker = new TypeChecker();
+      const errors = this.checker.check(ast);
+      if (errors.length > 0) {
+        this.errors.push(...errors);
+        throw new TypeError(errors);
+      }
+    }
+    return ast;
+  }
+  public parseExpression(code: string): Expression {
+    const processedCode = this.preprocessor(code);
+    const expr = this.feedParser(processedCode)[0];
+    return expr;
+  }
+  private feedParser(code: string): any {
+    const parser = new nearley.Parser(
+      nearley.Grammar.fromCompiled(grammar as any),
+    );
+    try {
+      parser.feed(code);
+      parser.finish();
+    } catch (e: unknown) {
+      const error = e as NearleyError; // Assert the shape
+      if (error.token) {
+        throw new UnexpectedToken(error.token);
+      }
+      throw error;
+    }
+    const { results } = parser;
+    if (results.length > 1) throw new AmbiguityError(results.length);
+    if (results.length == 0) return [];
+    return results[0];
+  }
+  public typeOfExpression(code: string): string {
+    if (!this.config.typecheck || !this.checker)
+      throw new Error("Type checking not initialized. Did you load a file?");
+
+    const expr = this.parseExpression(code);
+    return this.checker.inferExpression(expr);
+  }
+  public getKnownSymbols(): string[] {
+    if (!this.config.typecheck || !this.checker) return [];
+    return this.checker.getKnownSymbols();
+  }
+}