typeclasses can have required methods and required functions

src/build_visitor.cpp

@@ -269,14 +269,15 @@ void BuildVisitor::Visit(TypeclassDefinitionStatement* node) {
 
   size_t child_count = parse_node.NamedChildCount();
 
-  if (child_count > 1) {
-    node->requirements.resize(child_count - 1);
-
-    for (size_t i = 0; i + 1 < child_count; ++i) {
-        current_node_ = parse_node.NthNamedChild(i + 1);
-        node->requirements[i] = std::make_unique<FunctionDeclaration>();
-        Visit(node->requirements[i].get());
-    }
+  for (size_t i = 0; i + 1 < child_count; ++i) {
+      current_node_ = parse_node.NthNamedChild(i + 1);
+      if (parse_node.PreviousSibling().GetValue() != "var") {
+        node->function_requirements.push_back(std::make_unique<FunctionDeclaration>());
+        Visit(node->function_requirements.back().get());
+      } else {
+        node->method_requirements.push_back(std::make_unique<FunctionDeclaration>());
+        Visit(node->method_requirements.back().get());
+      }
   }
 
   current_node_ = parse_node;

src/find_symbols_visitor.cpp

@@ -160,10 +160,17 @@ void FindSymbolsVisitor::Visit(TypeclassDefinitionStatement* node) {
     current_info_.reset();
   }
 
-  info.requirements.reserve(node->requirements.size());
-  for (size_t i = 0; i < node->requirements.size(); ++i) {
-    Visit(node->requirements[i].get());
-    info.requirements[i] = std::move(std::any_cast<info::definition::FunctionDeclaration>(current_info_));
+  info.function_requirements.reserve(node->function_requirements.size());
+  for (size_t i = 0; i < node->function_requirements.size(); ++i) {
+    Visit(node->function_requirements[i].get());
+    info.function_requirements[i] = std::move(std::any_cast<info::definition::FunctionDeclaration>(current_info_));
+    current_info_.reset();
+  }
+
+  info.method_requirements.reserve(node->method_requirements.size());
+  for (size_t i = 0; i < node->method_requirements.size(); ++i) {
+    Visit(node->method_requirements[i].get());
+    info.method_requirements[i] = std::move(std::any_cast<info::definition::FunctionDeclaration>(current_info_));
     current_info_.reset();
   }
 

src/print_visitor.cpp

@@ -157,14 +157,22 @@ void PrintVisitor::Visit(AbstractTypeDefinitionStatement* node) {
 void PrintVisitor::Visit(TypeclassDefinitionStatement* node) {
   out_ << "[Typeclass] (";
   Visit(node->definition.get());
-  if (!node->requirements.empty()) {
+  if (!node->function_requirements.empty()) {
     out_ << ") : (\n";
   }
-  for (auto& requirement : node->requirements) {
+  for (auto& requirement : node->function_requirements) {
     out_ << "& ";
     Visit(requirement.get());
     out_ << "\n";
   }
+  if (!node->method_requirements.empty()) {
+    out_ << ") : (\n";
+  }
+  for (auto& requirement : node->method_requirements) {
+    out_ << "& var ";
+    Visit(requirement.get());
+    out_ << "\n";
+  }
   out_ << ")\n";
 }
 

src/typed_print_visitor.cpp

@@ -218,14 +218,22 @@ void TypedPrintVisitor::Visit(TypeclassDefinitionStatement* node) {
 
   out_ << "] (";
   Visit(node->definition.get());
-  if (!node->requirements.empty()) {
+  if (!node->function_requirements.empty()) {
     out_ << ") : (\n";
   }
-  for (auto& requirement : node->requirements) {
+  for (auto& requirement : node->function_requirements) {
     out_ << "& ";
     Visit(requirement.get());
     out_ << "\n";
   }
+  if (!node->method_requirements.empty()) {
+    out_ << ") : (\n";
+  }
+  for (auto& requirement : node->method_requirements) {
+    out_ << "& var ";
+    Visit(requirement.get());
+    out_ << "\n";
+  }
   out_ << ")\n";
 }
 

src/visitor.cpp

@@ -357,8 +357,11 @@ void Visitor::Visit(AbstractTypeDefinitionStatement* node) {
 
 void Visitor::Visit(TypeclassDefinitionStatement* node) {
   Visit(node->definition.get());
-  for (auto& requirement : node->requirements) {
-    Visit(requirement.get());
+  for (auto& function_requirement : node->function_requirements) {
+    Visit(function_requirement.get());
+  }
+  for (auto& method_requirement : node->method_requirements) {
+    Visit(method_requirement.get());
   }
 }