yukigo-haskell-parser 0.1.0 → 0.1.2

package/src/typechecker/DeclarationCollector.ts

@@ -1,104 +1,157 @@
-import {
-  ASTNode,
-  Record,
-  TypeAlias,
-  TypeSignature,
-  Visitor,
-} from "yukigo-ast";
-import {
-  functionType,
-  Type,
-  TypeConstructor,
-  TypeScheme,
-  TypeVar,
-} from "./checker.js";
-import { CoreHM } from "./core.js";
-import { TypeBuilder } from "./TypeBuilder.js";
-
-const builder = new TypeBuilder(new CoreHM());
-
-export class DeclarationCollectorVisitor implements Visitor<void> {
-  constructor(
-    private errors: string[],
-    private typeAliasMap: Map<string, Type>,
-    private recordMap: Map<string, Type>,
-    private signatureMap: Map<string, TypeScheme>,
-    private coreHM: CoreHM
-  ) {}
-
-  visitTypeAlias(node: TypeAlias) {
-    const typeAliasIdentifier = node.identifier.value;
-    if (
-      this.typeAliasMap.has(typeAliasIdentifier) ||
-      this.recordMap.has(typeAliasIdentifier)
-    ) {
-      this.errors.push(`Multiple declaration of '${typeAliasIdentifier}'.`);
-      return;
-    }
-
-    const { type, constraints } = builder.build(node.value);
-    this.typeAliasMap.set(typeAliasIdentifier, type);
-  }
-  visitRecord(node: Record) {
-    const recordIdentifier = node.name.value;
-    if (
-      this.typeAliasMap.has(recordIdentifier) ||
-      this.recordMap.has(recordIdentifier)
-    ) {
-      this.errors.push(`Multiple declaration of '${recordIdentifier}'.`);
-      return;
-    }
-
-    // Save the record type itself
-    const recordType: TypeConstructor = {
-      type: "TypeConstructor",
-      name: recordIdentifier,
-      args: [],
-    };
-    this.recordMap.set(recordIdentifier, recordType);
-
-    // Add constructors to signature map as type schemes
-    for (const cons of node.contents) {
-      if (this.signatureMap.has(cons.name.value)) {
-        this.errors.push(`Constructor '${cons.name}' is already defined`);
-        continue;
-      }
-      const paramTypes = cons.fields.map((field) => builder.build(field.value));
-      const returnType: TypeConstructor = {
-        type: "TypeConstructor",
-        name: recordIdentifier,
-        args: paramTypes.map(() => this.coreHM.freshVar()),
-      };
-
-      const funcType: Type = paramTypes.reduceRight(
-        (acc, param) => functionType(param.type, acc),
-        returnType
-      );
-
-      // Generalize all free variables in the constructor type
-      const scheme = this.coreHM.generalize(new Map(), funcType);
-      this.signatureMap.set(cons.name.value, scheme);
-    }
-  }
-  visitTypeSignature(node: TypeSignature) {
-    const functionName = node.identifier.value;
-    if (this.signatureMap.has(functionName)) {
-      this.errors.push(
-        `Function '${functionName}' has multiple type signatures`
-      );
-      return;
-    }
-    const typeVarMap = new Map<string, TypeVar>();
-    const { type, constraints } = builder.build(node.body, typeVarMap);
-    const quantifiers = Array.from(typeVarMap.values()).map((tv) => tv.id);
-    this.signatureMap.set(functionName, {
-      type: "TypeScheme",
-      quantifiers,
-      body: type,
-      constraints,
-    });
-  }
-  visit(node: ASTNode): void {
-    node.accept(this);
-  }
-}
+import {
+  ASTNode,
+  Record,
+  TypeAlias,
+  TypeSignature,
+  Visitor,
+  TestGroup,
+  Test,
+  Assert,
+  TypeClass,
+  Instance,
+  Equation,
+  TypePattern,
+  SimpleType,
+  ListType,
+} from "yukigo-ast";
+import {
+  functionType,
+  Type,
+  TypeConstructor,
+  TypeScheme,
+  TypeVar,
+} from "./checker.js";
+import { CoreHM } from "./core.js";
+import { TypeBuilder } from "./TypeBuilder.js";
+import { typeMappings } from "../utils/types.js";
+
+const builder = new TypeBuilder(new CoreHM());
+
+export class DeclarationCollectorVisitor implements Visitor<void> {
+  constructor(
+    private errors: string[],
+    private typeAliasMap: Map<string, Type>,
+    private recordMap: Map<string, Type>,
+    private signatureMap: Map<string, TypeScheme>,
+    private coreHM: CoreHM
+  ) {}
+
+  visitTypeAlias(node: TypeAlias) {
+    const typeAliasIdentifier = node.identifier.value;
+    if (
+      this.typeAliasMap.has(typeAliasIdentifier) ||
+      this.recordMap.has(typeAliasIdentifier)
+    ) {
+      this.errors.push(`Multiple declaration of '${typeAliasIdentifier}'.`);
+      return;
+    }
+
+    const { type, constraints } = builder.build(node.value);
+    this.typeAliasMap.set(typeAliasIdentifier, type);
+  }
+  visitRecord(node: Record) {
+    const recordIdentifier = node.name.value;
+    if (
+      this.typeAliasMap.has(recordIdentifier) ||
+      this.recordMap.has(recordIdentifier)
+    ) {
+      this.errors.push(`Multiple declaration of '${recordIdentifier}'.`);
+      return;
+    }
+
+    // Save the record type itself
+    const recordType: TypeConstructor = {
+      type: "TypeConstructor",
+      name: recordIdentifier,
+      args: [],
+    };
+    this.recordMap.set(recordIdentifier, recordType);
+
+    // Add constructors to signature map as type schemes
+    for (const cons of node.contents) {
+      if (this.signatureMap.has(cons.name.value)) {
+        this.errors.push(`Constructor '${cons.name}' is already defined`);
+        continue;
+      }
+      const paramTypes = cons.fields.map((field) => builder.build(field.value));
+      const returnType: TypeConstructor = {
+        type: "TypeConstructor",
+        name: recordIdentifier,
+        args: paramTypes.map(() => this.coreHM.freshVar()),
+      };
+
+      const funcType: Type = paramTypes.reduceRight(
+        (acc, param) => functionType(param.type, acc),
+        returnType
+      );
+
+      // Generalize all free variables in the constructor type
+      const scheme = this.coreHM.generalize(new Map(), funcType);
+      this.signatureMap.set(cons.name.value, scheme);
+    }
+  }
+
+  visitTypeClass(node: TypeClass) {
+    const className = node.name.value;
+    if (!this.coreHM.typeClasses.has(className)) {
+       this.coreHM.typeClasses.set(className, []);
+    }
+
+    // Register method signatures
+    for (const sig of node.signatures) {
+      this.visitTypeSignature(sig);
+    }
+  }
+
+  visitInstance(node: Instance) {
+    const className = node.className.value;
+    let yukigoTypeName = "YuUnknown";
+
+    if (node.type instanceof SimpleType) {
+      yukigoTypeName = typeMappings[node.type.value] || node.type.value;
+    } else if (node.type instanceof ListType) {
+      yukigoTypeName = "YuList";
+    }
+
+    let instances = this.coreHM.typeClasses.get(className);
+    if (!instances) {
+      instances = [];
+      this.coreHM.typeClasses.set(className, instances);
+    }
+
+    if (!instances.includes(yukigoTypeName)) {
+      instances.push(yukigoTypeName);
+    }
+  }
+
+  visitTypeSignature(node: TypeSignature) {
+    const functionName = node.identifier.value;
+    if (this.signatureMap.has(functionName)) {
+      this.errors.push(
+        `Function '${functionName}' has multiple type signatures`
+      );
+      return;
+    }
+    const typeVarMap = new Map<string, TypeVar>();
+    const { type, constraints } = builder.build(node.body, typeVarMap);
+    const quantifiers = Array.from(typeVarMap.values()).map((tv) => tv.id);
+    this.signatureMap.set(functionName, {
+      type: "TypeScheme",
+      quantifiers,
+      body: type,
+      constraints,
+    });
+  }
+  visitTestGroup(node: TestGroup): void {
+    node.group.accept(this);
+  }
+  visitTest(node: Test): void {
+    node.body.accept(this);
+  }
+  visitAssert(node: Assert): void {
+    // assertions don't contain declarations
+  }
+  visit(node: ASTNode): void {
+    node.accept(this);
+  }
+}

package/src/typechecker/TypeBuilder.ts

@@ -1,148 +1,150 @@
-import {
-  SimpleType,
-  TypeVar as ASTTypeVar,
-  ListType,
-  TupleType,
-  ParameterizedType,
-  TypeApplication,
-  Constraint,
-  Type as YukigoType,
-  ConstrainedType,
-  ASTNode,
-} from "yukigo-ast";
-import { typeMappings } from "../utils/types.js";
-import { CoreHM } from "./core.js";
-import { functionType, Type, TypeConstructor, TypeVar } from "./checker.js";
-
-export class TypeBuilder {
-  constructor(private coreHM: CoreHM) {}
-
-  build(
-    node: YukigoType,
-    typeVarMap: Map<string, TypeVar> = new Map()
-  ): { type: Type; constraints: Map<number, string[]> } {
-    const constraintsMap = new Map<number, string[]>();
-
-    // Local visitor to walk Yukigo type AST
-    const visitor = {
-      visitSimpleType: (n: SimpleType): Type => {
-        if (/^[a-z]/.test(n.value)) {
-          // Lowercase = type variable
-          if (!typeVarMap.has(n.value)) {
-            typeVarMap.set(n.value, {
-              type: "TypeVar",
-              ...this.coreHM.freshVar(),
-              name: n.value,
-            });
-          }
-          // Collect constraints on this type var
-          for (const constraint of n.constraints) {
-            this.processConstraint(constraint, typeVarMap, constraintsMap);
-          }
-          return typeVarMap.get(n.value)!;
-        }
-
-        // Uppercase = type constructor (e.g., Int, Bool, List)
-        const primitive = typeMappings[n.value] || n.value;
-        return {
-          type: "TypeConstructor",
-          name: primitive,
-          args: [],
-        };
-      },
-
-      visitTypeVar: (n: ASTTypeVar): Type => {
-        // Same as SimpleType for type variables
-        if (!typeVarMap.has(n.value)) {
-          typeVarMap.set(n.value, {
-            type: "TypeVar",
-            ...this.coreHM.freshVar(),
-            name: n.value,
-          });
-        }
-        for (const constraint of n.constraints) {
-          this.processConstraint(constraint, typeVarMap, constraintsMap);
-        }
-        return typeVarMap.get(n.value)!;
-      },
-
-      visitListType: (n: ListType): Type => {
-        const elementType = n.values.accept(visitor);
-        return {
-          type: "TypeConstructor",
-          name: "List",
-          args: [elementType],
-        };
-      },
-
-      visitTupleType: (n: TupleType): Type => {
-        const elementTypes = n.values.map((v) => v.accept(visitor));
-        return {
-          type: "TypeConstructor",
-          name: "Tuple",
-          args: elementTypes,
-        };
-      },
-
-      visitTypeApplication: (n: TypeApplication): Type => {
-        return this.coreHM.freshVar();
-      },
-
-      visitParameterizedType: (n: ParameterizedType): Type => {
-        // This represents function types with constraints, e.g.:
-        // (a, b) => c with Eq a
-        const returnType = n.returnType.accept(visitor);
-        const paramTypes = n.inputs.map((input) => input.accept(visitor));
-
-        // Build function type: a -> b -> c
-        const funcType = paramTypes.reduceRight(
-          (acc, param) => functionType(param, acc),
-          returnType
-        );
-
-        // Process constraints
-        for (const constraint of n.constraints) {
-          this.processConstraint(constraint, typeVarMap, constraintsMap);
-        }
-
-        return funcType;
-      },
-
-      visitConstrainedType: (n: ConstrainedType): Type => {
-        // This is unusual at top level; usually constraints appear on type vars or signatures
-        // For now, ignore or throw
-        throw new Error("ConstrainedType not expected in this context");
-      },
-      visit(node: ASTNode): Type {
-        return node.accept(visitor);
-      },
-    };
-
-    const type = node.accept(visitor);
-    return { type, constraints: constraintsMap };
-  }
-
-  private processConstraint(
-    constraint: Constraint,
-    typeVarMap: Map<string, { type: "TypeVar"; id: number }>,
-    constraintsMap: Map<number, string[]>
-  ): void {
-    // Assume constraint is of form `Eq a`, so first param is a type var
-    if (constraint.parameters.length === 0) return;
-
-    const firstParam = constraint.parameters[0];
-    // Only handle if it's a type variable
-    if (
-      (firstParam instanceof SimpleType || firstParam instanceof ASTTypeVar) &&
-      /^[a-z]/.test(firstParam.value)
-    ) {
-      const tv = typeVarMap.get(firstParam.value);
-      if (tv) {
-        if (!constraintsMap.has(tv.id)) {
-          constraintsMap.set(tv.id, []);
-        }
-        constraintsMap.get(tv.id)!.push(constraint.name);
-      }
-    }
-  }
-}
+import {
+  SimpleType,
+  TypeVar as ASTTypeVar,
+  ListType,
+  TupleType,
+  ParameterizedType,
+  TypeApplication,
+  Constraint,
+  Type as YukigoType,
+  ConstrainedType,
+  ASTNode,
+} from "yukigo-ast";
+import { typeMappings } from "../utils/types.js";
+import { CoreHM } from "./core.js";
+import { functionType, Type, TypeConstructor, TypeVar, stringType, charType } from "./checker.js";
+
+export class TypeBuilder {
+  constructor(private coreHM: CoreHM) {}
+
+  build(
+    node: YukigoType,
+    typeVarMap: Map<string, TypeVar> = new Map()
+  ): { type: Type; constraints: Map<number, string[]> } {
+    const constraintsMap = new Map<number, string[]>();
+
+    // Local visitor to walk Yukigo type AST
+    const visitor = {
+      visitSimpleType: (n: SimpleType): Type => {
+        if (/^[a-z]/.test(n.value)) {
+          // Lowercase = type variable
+          if (!typeVarMap.has(n.value)) {
+            typeVarMap.set(n.value, {
+              type: "TypeVar",
+              ...this.coreHM.freshVar(),
+              name: n.value,
+            });
+          }
+          // Collect constraints on this type var
+          for (const constraint of n.constraints) {
+            this.processConstraint(constraint, typeVarMap, constraintsMap);
+          }
+          return typeVarMap.get(n.value)!;
+        }
+
+        // Uppercase = type constructor (e.g., Int, Bool, List)
+        const primitive = typeMappings[n.value] || n.value;
+        if (primitive === "YuString") return stringType;
+        if (primitive === "YuChar") return charType;
+        return {
+          type: "TypeConstructor",
+          name: primitive,
+          args: [],
+        };
+      },
+
+      visitTypeVar: (n: ASTTypeVar): Type => {
+        // Same as SimpleType for type variables
+        if (!typeVarMap.has(n.value)) {
+          typeVarMap.set(n.value, {
+            type: "TypeVar",
+            ...this.coreHM.freshVar(),
+            name: n.value,
+          });
+        }
+        for (const constraint of n.constraints) {
+          this.processConstraint(constraint, typeVarMap, constraintsMap);
+        }
+        return typeVarMap.get(n.value)!;
+      },
+
+      visitListType: (n: ListType): Type => {
+        const elementType = n.values.accept(visitor);
+        return {
+          type: "TypeConstructor",
+          name: "List",
+          args: [elementType],
+        };
+      },
+
+      visitTupleType: (n: TupleType): Type => {
+        const elementTypes = n.values.map((v) => v.accept(visitor));
+        return {
+          type: "TypeConstructor",
+          name: "Tuple",
+          args: elementTypes,
+        };
+      },
+
+      visitTypeApplication: (n: TypeApplication): Type => {
+        return this.coreHM.freshVar();
+      },
+
+      visitParameterizedType: (n: ParameterizedType): Type => {
+        // This represents function types with constraints, e.g.:
+        // (a, b) => c with Eq a
+        const returnType = n.returnType.accept(visitor);
+        const paramTypes = n.inputs.map((input) => input.accept(visitor));
+
+        // Build function type: a -> b -> c
+        const funcType = paramTypes.reduceRight(
+          (acc, param) => functionType(param, acc),
+          returnType
+        );
+
+        // Process constraints
+        for (const constraint of n.constraints) {
+          this.processConstraint(constraint, typeVarMap, constraintsMap);
+        }
+
+        return funcType;
+      },
+
+      visitConstrainedType: (n: ConstrainedType): Type => {
+        // This is unusual at top level; usually constraints appear on type vars or signatures
+        // For now, ignore or throw
+        throw new Error("ConstrainedType not expected in this context");
+      },
+      visit(node: ASTNode): Type {
+        return node.accept(visitor);
+      },
+    };
+
+    const type = node.accept(visitor);
+    return { type, constraints: constraintsMap };
+  }
+
+  private processConstraint(
+    constraint: Constraint,
+    typeVarMap: Map<string, { type: "TypeVar"; id: number }>,
+    constraintsMap: Map<number, string[]>
+  ): void {
+    // Assume constraint is of form `Eq a`, so first param is a type var
+    if (constraint.parameters.length === 0) return;
+
+    const firstParam = constraint.parameters[0];
+    // Only handle if it's a type variable
+    if (
+      (firstParam instanceof SimpleType || firstParam instanceof ASTTypeVar) &&
+      /^[a-z]/.test(firstParam.value)
+    ) {
+      const tv = typeVarMap.get(firstParam.value);
+      if (tv) {
+        if (!constraintsMap.has(tv.id)) {
+          constraintsMap.set(tv.id, []);
+        }
+        constraintsMap.get(tv.id)!.push(constraint.name);
+      }
+    }
+  }
+}