yukigo-haskell-parser 0.1.3 → 0.2.2

package/src/utils/helpers.ts

@@ -1,29 +1,34 @@
-import { inspect } from "util";
-import { AST } from "yukigo-ast";
-import { Function } from "yukigo-ast";
-
-export function groupFunctionDeclarations(ast: AST): AST {
-  const groups: Record<string, Function[]> = {};
-  const others: AST = [];
-
-  for (const node of ast) {
-    if (node instanceof Function) {
-      const name = node.identifier.value;
-      if (!groups[name]) {
-        groups[name] = [];
-      }
-      groups[name].push(node);
-    } else {
-      others.push(node);
-    }
-  }
-
-  // Merge equations for each function name
-  const functionGroups: Function[] = Object.values(groups).map((functions) => {
-    const identifier = functions[0].identifier;
-    const allEquations = functions.flatMap((f) => f.equations);
-    return new Function(identifier, allEquations, identifier.loc);
-  });
-
-  return [...others, ...functionGroups];
-}
+import { AST } from "yukigo-ast";
+import { Function } from "yukigo-ast";
+
+export class UnexpectedNode extends Error {
+  constructor(nodeCons: string, context: string) {
+    super(`${nodeCons} not expected in ${context}.`)
+  }
+}
+
+export function groupFunctionDeclarations(ast: AST): AST {
+  const groups: Record<string, Function[]> = {};
+  const others: AST = [];
+
+  for (const node of ast) {
+    if (node instanceof Function) {
+      const name = node.identifier.value;
+      if (!groups[name]) {
+        groups[name] = [];
+      }
+      groups[name].push(node);
+    } else {
+      others.push(node);
+    }
+  }
+
+  // Merge equations for each function name
+  const functionGroups: Function[] = Object.values(groups).map((functions) => {
+    const identifier = functions[0].identifier;
+    const allEquations = functions.flatMap((f) => f.equations);
+    return new Function(identifier, allEquations, identifier.loc);
+  });
+
+  return [...others, ...functionGroups];
+}

package/src/utils/types.ts

@@ -1,63 +1,75 @@
-import { YukigoPrimitive } from "yukigo-ast";
-
-export const keywords = [
-  "type",
-  "where",
-  "in",
-  "if",
-  "else",
-  "then",
-  "data",
-  "case",
-  "error",
-  "class",
-  "do",
-  "default",
-  "deriving",
-  "import",
-  "infix",
-  "infixl",
-  "infixr",
-  "instance",
-  "let",
-  "module",
-  "newtype",
-  "of",
-  "qualified",
-  "hiding",
-  "foreign",
-  "describe",
-  "it",
-  "shouldBe",
-  "shouldNotBe",
-  "shouldSatisfy",
-  "shouldThrow"
-];
-
-export const typeMappings: { [key: string]: YukigoPrimitive } = {
-  Float: "YuNumber",
-  Double: "YuNumber",
-  Int: "YuNumber",
-  Integer: "YuNumber",
-  String: "YuString",
-  Char: "YuChar",
-  Boolean: "YuBoolean",
-  Bool: "YuBoolean",
-};
-
-export const typeClasses: Map<string, string[]> = new Map([
-  ["Bounded", ["YuChar", "YuNumber"]],
-  ["Enum", ["YuChar", "YuNumber"]],
-  ["Ord", ["YuNumber", "YuString", "YuChar"]],
-  ["Eq", ["YuNumber", "YuString", "YuChar", "YuBoolean"]],
-  ["Floating", ["YuNumber"]],
-  ["Fractional", ["YuNumber"]],
-  ["Integral", ["YuNumber"]],
-  ["Num", ["YuNumber"]],
-  ["Random", ["YuBoolean", "YuChar", "YuNumber"]],
-  ["Read", ["YuList", "YuChar", "YuNumber"]],
-  ["Real", ["YuNumber"]],
-  ["RealFloat", ["YuNumber"]],
-  ["RealFrac", ["YuNumber"]],
-  ["Show", ["YuNumber", "YuString", "YuChar", "YuList"]],
-]);
+export const keywords = [
+  "type",
+  "where",
+  "in",
+  "if",
+  "else",
+  "then",
+  "data",
+  "case",
+  "error",
+  "class",
+  "do",
+  "default",
+  "deriving",
+  "import",
+  "infix",
+  "infixl",
+  "infixr",
+  "instance",
+  "let",
+  "module",
+  "newtype",
+  "of",
+  "qualified",
+  "hiding",
+  "foreign",
+  "describe",
+  "it",
+  "shouldBe",
+  "shouldNotBe",
+  "shouldSatisfy",
+  "shouldThrow"
+];
+
+export enum YUTYPES { // primitivos 
+  YuNumber = "YuNumber", 
+  YuString = "YuString", 
+  YuChar = "YuChar", 
+  YuBoolean = "YuBoolean", 
+  YuNil = "YuNil", 
+  // constructores 
+  Tuple = "Tuple", 
+  List = "List", 
+  Arrow = "->" 
+}
+
+export const typeMappings: { [key: string]: YUTYPES } = {
+  Float: YUTYPES.YuNumber,
+  Double: YUTYPES.YuNumber,
+  Int: YUTYPES.YuNumber,
+  Integer: YUTYPES.YuNumber,
+  String: YUTYPES.YuString,
+  Char: YUTYPES.YuChar,
+  Boolean: YUTYPES.YuBoolean,
+  Bool: YUTYPES.YuBoolean,
+};
+
+export const typeClasses: Map<string, YUTYPES[]> = new Map([
+  ["Bounded", [YUTYPES.YuChar, YUTYPES.YuNumber]],
+  ["Enum", [YUTYPES.YuChar, YUTYPES.YuNumber]],
+  ["Ord", [YUTYPES.YuNumber, YUTYPES.YuString, YUTYPES.YuChar]],
+  ["Eq", [YUTYPES.YuNumber, YUTYPES.YuString, YUTYPES.YuChar, YUTYPES.YuBoolean]],
+  ["Floating", [YUTYPES.YuNumber]],
+  ["Fractional", [YUTYPES.YuNumber]],
+  ["Integral", [YUTYPES.YuNumber]],
+  ["Num", [YUTYPES.YuNumber]],
+  ["Random", [YUTYPES.YuBoolean, YUTYPES.YuChar, YUTYPES.YuNumber]],
+  ["Read", [YUTYPES.YuChar, YUTYPES.YuNumber]],
+  
+  ["Real", [YUTYPES.YuNumber]],
+  ["RealFloat", [YUTYPES.YuNumber]],
+  ["RealFrac", [YUTYPES.YuNumber]],
+  ["Show", [YUTYPES.YuNumber, YUTYPES.YuString, YUTYPES.YuChar]],
+  
+]);

package/tests/hspec.spec.ts

@@ -1,92 +1,95 @@
-import { expect } from "chai";
-import { YukigoHaskellParser } from "../src/index.js";
-import {
-  TestGroup,
-  Test,
-  Assert,
-  Equality,
-  Truth,
-  Failure,
-  Raise,
-  NumberPrimitive,
-  SymbolPrimitive,
-  Application,
-  StringPrimitive,
-  BooleanPrimitive
-} from "yukigo-ast";
-
-describe("HSpec Parsing", () => {
-  const parser = new YukigoHaskellParser("", { typecheck: true, includePrims: false });
-
-  it("should parse describe and it blocks", () => {
-    const code = `
-describe "Math" do
-  it "adds 1 and 1" do
-    (1 + 1) shouldBe 2
-`;
-    const ast = parser.parse(code);
-    expect(ast).to.have.lengthOf(1);
-    expect(ast[0]).to.be.instanceOf(TestGroup);
-    
-    const group = ast[0] as TestGroup;
-    expect(group.name).to.be.instanceOf(StringPrimitive);
-    expect((group.name as StringPrimitive).value).to.equal("Math");
-    
-    expect(group.group.statements).to.have.lengthOf(1);
-    expect(group.group.statements[0]).to.be.instanceOf(Test);
-    
-    const test = group.group.statements[0] as Test;
-    expect(test.name).to.be.instanceOf(StringPrimitive);
-    expect((test.name as StringPrimitive).value).to.equal("adds 1 and 1");
-    
-    expect(test.body.statements).to.have.lengthOf(1);
-    expect(test.body.statements[0]).to.be.instanceOf(Assert);
-    
-    const assert = test.body.statements[0] as Assert;
-    expect(assert.negated).to.be.instanceOf(BooleanPrimitive);
-    expect((assert.negated as BooleanPrimitive).value).to.be.false;
-    expect(assert.body).to.be.instanceOf(Equality);
-    
-    const equality = assert.body as Equality;
-    expect(equality.expected).to.be.instanceOf(NumberPrimitive);
-    expect((equality.expected as NumberPrimitive).value).to.equal(2);
-  });
-
-  it("should parse shouldNotBe", () => {
-    const code = `it "negation" do 1 shouldNotBe 2`;
-    const ast = parser.parse(code);
-    const test = ast[0] as Test;
-    const assert = test.body.statements[0] as Assert;
-    expect((assert.negated as BooleanPrimitive).value).to.be.true;
-    expect(assert.body).to.be.instanceOf(Equality);
-  });
-
-  it("should parse shouldSatisfy", () => {
-    const code = `it "satisfy" do 5 shouldSatisfy odd`;
-    const ast = parser.parse(code);
-    const test = ast[0] as Test;
-    const assert = test.body.statements[0] as Assert;
-    expect(assert.body).to.be.instanceOf(Truth);
-    
-    const truth = assert.body as Truth;
-    expect(truth.body).to.be.instanceOf(Application);
-    const app = truth.body as Application;
-    expect(app.functionExpr).to.be.instanceOf(SymbolPrimitive);
-    expect((app.functionExpr as SymbolPrimitive).value).to.equal("odd");
-    expect(app.parameter).to.be.instanceOf(NumberPrimitive);
-    expect((app.parameter as NumberPrimitive).value).to.equal(5);
-  });
-
-  it("should parse shouldThrow", () => {
-    const code = `it "throws" do error "fail" shouldThrow anyException`;
-    const ast = parser.parse(code);
-    const test = ast[0] as Test;
-    const assert = test.body.statements[0] as Assert;
-    expect(assert.body).to.be.instanceOf(Failure);
-    
-    const failure = assert.body as Failure;
-    expect(failure.func).to.be.instanceOf(Raise);
-    expect(failure.message).to.be.instanceOf(SymbolPrimitive);
-    expect((failure.message as SymbolPrimitive).value).to.equal("anyException");
-  });
-});
+import { expect } from "chai";
+import { YukigoHaskellParser } from "../src/index.js";
+import {
+  TestGroup,
+  Test,
+  Assert,
+  Equality,
+  Truth,
+  Failure,
+  Raise,
+  NumberPrimitive,
+  SymbolPrimitive,
+  Application,
+  StringPrimitive,
+  BooleanPrimitive,
+} from "yukigo-ast";
+
+describe("HSpec Parsing", () => {
+  const parser = new YukigoHaskellParser("", {
+    typecheck: true,
+    includePrims: false,
+  });
+
+  it("should parse describe and it blocks", () => {
+    const code = `
+describe "Math" do
+  it "adds 1 and 1" do
+    (1 + 1) shouldBe 2
+`;
+    const ast = parser.parse(code);
+    expect(ast).to.have.lengthOf(1);
+    expect(ast[0]).to.be.instanceOf(TestGroup);
+
+    const group = ast[0] as TestGroup;
+    expect(group.name).to.be.instanceOf(StringPrimitive);
+    expect((group.name as StringPrimitive).value).to.equal("Math");
+
+    expect(group.group.statements).to.have.lengthOf(1);
+    expect(group.group.statements[0]).to.be.instanceOf(Test);
+
+    const test = group.group.statements[0] as Test;
+    expect(test.name).to.be.instanceOf(StringPrimitive);
+    expect((test.name as StringPrimitive).value).to.equal("adds 1 and 1");
+
+    expect(test.body.statements).to.have.lengthOf(1);
+    expect(test.body.statements[0]).to.be.instanceOf(Assert);
+
+    const assert = test.body.statements[0] as Assert;
+    expect(assert.negated).to.be.instanceOf(BooleanPrimitive);
+    expect((assert.negated as BooleanPrimitive).value).to.be.false;
+    expect(assert.body).to.be.instanceOf(Equality);
+
+    const equality = assert.body as Equality;
+    expect(equality.expected).to.be.instanceOf(NumberPrimitive);
+    expect((equality.expected as NumberPrimitive).value).to.equal(2);
+  });
+
+  it("should parse shouldNotBe", () => {
+    const code = `it "negation" do 1 shouldNotBe 2`;
+    const ast = parser.parse(code);
+    const test = ast[0] as Test;
+    const assert = test.body.statements[0] as Assert;
+    expect((assert.negated as BooleanPrimitive).value).to.be.true;
+    expect(assert.body).to.be.instanceOf(Equality);
+  });
+
+  it("should parse shouldSatisfy", () => {
+    const code = `it "satisfy" do 5 shouldSatisfy odd`;
+    const ast = parser.parse(code);
+    const test = ast[0] as Test;
+    const assert = test.body.statements[0] as Assert;
+    expect(assert.body).to.be.instanceOf(Truth);
+
+    const truth = assert.body as Truth;
+    expect(truth.body).to.be.instanceOf(Application);
+    const app = truth.body as Application;
+    expect(app.functionExpr).to.be.instanceOf(SymbolPrimitive);
+    expect((app.functionExpr as SymbolPrimitive).value).to.equal("odd");
+    expect(app.parameter).to.be.instanceOf(NumberPrimitive);
+    expect((app.parameter as NumberPrimitive).value).to.equal(5);
+  });
+
+  it("should parse shouldThrow", () => {
+    const code = `it "throws" do error "fail" shouldThrow anyException`;
+    const ast = parser.parse(code);
+    const test = ast[0] as Test;
+    const assert = test.body.statements[0] as Assert;
+    expect(assert.body).to.be.instanceOf(Failure);
+
+    const failure = assert.body as Failure;
+    expect(failure.func).to.be.instanceOf(Raise);
+    expect(failure.message).to.be.instanceOf(SymbolPrimitive);
+    expect((failure.message as SymbolPrimitive).value).to.equal("anyException");
+  });
+});