yukigo-haskell-parser 0.1.0 → 0.1.2

package/src/index.ts

@@ -1,55 +1,192 @@
-import grammar from "./parser/grammar.js";
-import nearley from "nearley";
-import { groupFunctionDeclarations } from "./utils/helpers.js";
-import { TypeChecker } from "./typechecker/checker.js";
-import { AST, YukigoParser } from "yukigo-ast";
-import { inspect } from "util";
-import { preprocessor } from "./parser/layoutPreprocessor.js";
-import { preludeCode } from "./prelude.js";
-
-export class YukigoHaskellParser implements YukigoParser {
-  public errors: string[] = [];
-  private prelude: string;
-  constructor(prelude?: string) {
-    this.errors = [];
-    this.prelude = prelude ?? preludeCode;
-  }
-
-  public parse(code: string): AST {
-    const processedCode = preprocessor(code);
-    const parser = new nearley.Parser(nearley.Grammar.fromCompiled(grammar));
-    try {
-      parser.feed(this.prelude + "\n\n" + processedCode);
-      parser.finish();
-    } catch (error) {
-      console.log(error)
-      if ("token" in error) {
-        const token = error.token;
-        const message = `Parser: Unexpected '${token.type}' token '${token.value}' at line ${token.line} col ${token.col}.`;
-        this.errors.push(message);
-        throw Error(message);
-      }
-      throw error;
-    }
-    if (parser.results.length > 1) {
-      const msg = `Parser: Too much ambiguity. ${parser.results.length} ASTs parsed. Output not generated.`;
-      this.errors.push(msg);
-      throw Error(msg);
-    }
-    if (parser.results.length == 0) {
-      this.errors.push("Parser did not generate an AST.");
-      throw Error("Parser did not generate an AST.");
-    }
-    const ast = groupFunctionDeclarations(parser.results[0]);
-    try {
-      const typeChecker = new TypeChecker();
-      const errors = typeChecker.check(ast);
-      if (errors.length > 0) {
-        this.errors.push(...errors);
-      }
-    } catch (error) {
-      console.log(error);
-    }
-    return ast;
-  }
-}
+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();
+  }
+}