grammar refactoring: printer_visitor fixed

include/interpreter_tree.hpp

@@ -255,7 +255,7 @@ struct Sources {
 // ----------------- Namespaces, partittions -----------------
 
 struct Namespace {
-  bool is_const;
+  enum { Const, Var } modifier;
   std::optional<ExtendedName> name;
   TypeIdentifier type;
   std::unique_ptr<Sources> scope;
@@ -284,6 +284,7 @@ struct ImportStatement {
 };
 
 struct AliasDefinitionStatement {
+  enum {Alias, Type, Let} modifier;
   TypeIdentifier type;
   std::vector<AbstractTypeIdentifier> parameters;
   std::unique_ptr<ParametrizedType> value;
@@ -338,7 +339,7 @@ struct TypeDefinition {
 
 struct DefinitionParameter {
   AbstractTypeIdentifier type;
-  std::vector<std::unique_ptr<TypeclassUsage>> typeclasses;
+  std::vector<TypeclassUsage> typeclasses;
 };
 
 // ----------------- Flow control -----------------
@@ -410,10 +411,10 @@ struct UnaryOperatorExpression {
 
 struct ReferenceExpression {
   std::vector<ReferenceType> references;
-  ScopedStatement expression;
+  std::unique_ptr<ScopedStatement> expression;
 };
 
-// Simple Expressions -----------------
+// Other Expressions -----------------
 
 struct FunctionCallExpression {
   std::unique_ptr<NameExpression> name;
@@ -455,19 +456,19 @@ struct NameExpression {
 };
 
 struct TupleName {
-  std::vector<std::unique_ptr<ScopedAnyName>> names;
+  std::vector<ScopedAnyName> names;
 };
 
 struct VariantName {
-  std::vector<std::unique_ptr<ScopedAnyName>> names;
+  std::vector<ScopedAnyName> names;
 };
 
 struct AnnotatedName {
   NameIdentifier name;
-  std::optional<std::unique_ptr<ScopedAnyType>> type;
+  std::optional<ScopedAnyType> type;
 };
 
-// TODO ?? mark all optional fields ??
+// ----------------- Type, typeclass, etc. -----------------
 
 // Type -----------------
 
@@ -477,7 +478,7 @@ struct FunctionType {
 
 struct TupleType {
   std::optional<Constructor> type;
-  std::vector<std::pair<std::optional<ExtendedName>, ExtendedScopedAnyType>> entities;
+  std::vector<std::pair<std::optional<ExtendedName>, std::unique_ptr<ExtendedScopedAnyType>>> entities;
 };
 
 struct VariantType {
@@ -487,7 +488,7 @@ struct VariantType {
 
 struct AnnotatedType {
   std::unique_ptr<TypeExpression> type_expression;
-  std::vector<std::unique_ptr<TypeclassUsage>> annotations;
+  std::vector<TypeclassUsage> annotations;
 };
 
 struct ParametrizedType {

include/print_visitor.hpp

@@ -12,8 +12,6 @@ public:
   explicit PrintVisitor(std::ostream& out) : out_(out) {}
 
 private:
-  void Visit(Node* node) override;
-
   // Sources -----------------
 
   void Visit(SourceFile* node) override;
@@ -27,23 +25,19 @@ private:
   // Definitions -----------------
 
   void Visit(ImportStatement* node) override;
-  void Visit(UsageDefinition* node) override;
+  void Visit(AliasDefinitionStatement* node) override;
-  void Visit(AliasDefinition* node) override;
+  void Visit(VariableDefinitionStatement* node) override;
-  void Visit(VariableDefinition* node) override;
   void Visit(FunctionDeclaration* node) override;
-  void Visit(FunctionDefinition* node) override;
+  void Visit(FunctionDefinitionStatement* node) override;
-  void Visit(AliasTypeDefinition* node) override;
+  void Visit(TypeDefinitionStatement* node) override;
-  void Visit(TypeDefinition* node) override;
+  void Visit(AbstractTypeDefinitionStatement* node) override;
-  void Visit(TypeclassDefinition* node) override;
+  void Visit(TypeclassDefinitionStatement* node) override;
 
   // Definition parts
 
-  void Visit(DefinedName* node) override;
+  void Visit(FunctionDefinition* node) override;
-  void Visit(DefinedAnnotatedName* node) override;
+  void Visit(TypeDefinition* node) override;
-  void Visit(DefinedType* node) override;
-  void Visit(DefinedTypeclass* node) override;
   void Visit(DefinitionParameter* node) override;
-  void Visit(DefinitionArgument* node) override;
 
   // Flow control -----------------
 
@@ -58,46 +52,50 @@ private:
   // Statements, expressions, blocks, etc. -----------------
 
   void Visit(Block* node) override;
-  void Visit(ScopedStatement* node) override;
 
-  void Visit(LoopControlExpression& node) override; // enum
+  void Visit(ScopedStatement* node) override;
 
   // Operators
 
   void Visit(BinaryOperatorExpression* node) override;
   void Visit(UnaryOperatorExpression* node) override;
+  void Visit(ReferenceExpression* node) override;
 
   // Simple Expressions
 
   void Visit(FunctionCallExpression* node) override;
+
   void Visit(TupleExpression* node) override;
   void Visit(VariantExpression* node) override;
   void Visit(ReturnExpression* node) override;
-
+  void Visit(TypeConstructor* node) override;
-  // Lambda
-
   void Visit(LambdaFunction* node) override;
+  void Visit(ArrayExpression* node) override;
+
+  void Visit(LoopControlExpression& node) override; // enum
 
   // Name
 
-  void Visit(NameSuperExpression* node) override;
   void Visit(NameExpression* node) override;
   void Visit(TupleName* node) override;
   void Visit(VariantName* node) override;
   void Visit(AnnotatedName* node) override;
 
+  // Type, typeclass, etc. -----------------
+
   // Type
 
-  void Visit(TypeConstructor* node) override;
+  void Visit(FunctionType* node) override;
   void Visit(TupleType* node) override;
   void Visit(VariantType* node) override;
   void Visit(AnnotatedType* node) override;
   void Visit(ParametrizedType* node) override;
   void Visit(TypeExpression* node) override;
 
+  void Visit(ExtendedScopedAnyType* node) override;
+
   // Typeclass
 
-  void Visit(AnnotatedTypeclass* node) override;
   void Visit(ParametrizedTypeclass* node) override;
   void Visit(TypeclassExpression* node) override;
 
@@ -109,6 +107,7 @@ private:
   void Visit(NumberLiteral* node) override;
   void Visit(StringLiteral* node) override;
   void Visit(CharLiteral* node) override;
+
 private:
   std::ostream& out_;
 };

src/print_visitor.cpp

@@ -1,15 +1,13 @@
 // for clangd
 #include "../include/print_visitor.hpp"
+#include <ctime>
 
 namespace interpreter {
 
-void PrintVisitor::Visit(Node* node) {
-  out_ << "[Node]\n";
-}
-
 // Sources -----------------
+
 void PrintVisitor::Visit(SourceFile* node) {
-  out_ << "(SourceFile\n\n";
+  out_ << "[SourceFile] (\n\n";
   for (auto& statement : node->statements) {
     if (std::holds_alternative<Partition>(statement)) {
       Visit(&std::get<Partition>(statement));
@@ -19,22 +17,22 @@ void PrintVisitor::Visit(SourceFile* node) {
       // error
     }
   }
-  out_ << "\nSourceFile)\n";
+  out_ << "\n)\n";
 }
 
 void PrintVisitor::Visit(Sources* node) {
-  out_ << "(Sources\n\n";
+  out_ << "[Sources](\n";
   for (auto& statement : node->statements) {
     Visitor::Visit(statement);
   }
-  out_ << "\n)\n";
+  out_ << ")\n";
 }
 
 // Namespaces, partitions -----------------
 
 void PrintVisitor::Visit(Partition* node) {
-  out_ << "(Partition ";
+  out_ << "[Partition] ";
-  switch (node->type) {
+  switch (node->name) {
     case Partition::Test:
       out_ << "TEST";
       break;
@@ -56,211 +54,213 @@ void PrintVisitor::Visit(Partition* node) {
   }
   out_ << " {\n";
   Visit(node->scope.get());
-  out_ << "} )\n";
+  out_ << "}\n";
 }
 
 void PrintVisitor::Visit(Namespace* node) {
-  out_ << "(Namespace ";
+  out_ << "[Namespace] ";
-  if (std::holds_alternative<std::unique_ptr<DefinedAnnotatedName>>(node->name)) {
+  if (node->name.has_value()) {
-    if (node->is_const) {
+    switch (node->modifier) {
-      out_ << "const ";
+      case Namespace::Const:
-    } else {
+        out_ << "const ";
-      out_ << "var ";
+        break;
+      case Namespace::Var:
+        out_ << "var ";
+        break;
     }
-    Visit(std::get<std::unique_ptr<DefinedAnnotatedName>>(node->name).get());
+    Visit(&node->name.value());
-  } else if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->name)) {
-    Visit(std::get<std::unique_ptr<DefinedType>>(node->name).get());
-  } else {
-    // error
   }
+  Visit(&node->type);
   out_ << "{\n";
   Visit(node->scope.get());
-  out_ << "} )\n";
+  out_ << "}\n";
 }
 
 // Definitions -----------------
 
 void PrintVisitor::Visit(ImportStatement* node) {
-  out_ << "(Import \"" << node->module_name << "\" ";
+  if (node->name.has_value()) {
+    out_ << "[Use " << node->name.value() << "] = ";
+  }
+  out_ << "[Import " << node->module_name << "]";
   if (!node->symbols.empty()) {
-    out_ << '\n';
+    out_ << " (\n";
+    for (auto& symbol : node->symbols) {
+      Visitor::Visit(&symbol);
+      out_ << '\n';
+    }
+    out_ << ')';
   }
-  for (auto& symbol : node->symbols) {
+  out_ << '\n';
-    Visitor::Visit(symbol);
-    out_ << '\n';
-  }
-  out_ << ")\n";
 }
 
-void PrintVisitor::Visit(UsageDefinition* node) {
+void PrintVisitor::Visit(AliasDefinitionStatement* node) {
-  out_ << "(Usage ";
+  out_ << "[Alias ";
-  Visit(&node->name);
+  switch (node->modifier) {
-  out_ << " = ";
+    case AliasDefinitionStatement::Alias:
-  Visit(node->import_statement.get());
+    out_ << "alias";
-  out_ << ")\n";
+    break;
-}
+    case AliasDefinitionStatement::Type:
-
+    out_ << "type";
-void PrintVisitor::Visit(AliasDefinition* node) {
+    break;
-  out_ << "(Alias ";
+    case AliasDefinitionStatement::Let:
-  Visit(node->type.get());
+    out_ << "let";
-  out_ << " = ";
+    break;
+  }
+  out_ << ' ';
+  Visit(&node->type);
+  out_ << "] = (";
   Visit(node->value.get());
   out_ << ")\n";
 }
 
-void PrintVisitor::Visit(VariableDefinition* node) {
+void PrintVisitor::Visit(VariableDefinitionStatement* node) {
-  out_ << "(Variable " << (node->is_const ? "const" : "var") << ' ';
+  out_ << "[Variable ";
-  Visit(&node->name);
+  switch (node->modifier) {
-  out_ << " = ";
+    case VariableDefinitionStatement::Const:
+    out_ << "const";
+    break;
+    case VariableDefinitionStatement::Var:
+    out_ << "var";
+    break;
+  }
+  out_ << ' ';
+  Visitor::Visit(node->name);
+  out_ << "] = (";
   Visitor::Visit(node->value);
   out_ << ")\n";
 }
 
 void PrintVisitor::Visit(FunctionDeclaration* node) {
-  out_ << "(FunctionDeclaration ";
+  out_ << "[FunctionDeclaration ";
   Visit(&node->name);
-  out_ << "\n";
+  out_ << "] (";
   for (auto& parameter : node->parameters) {
     Visit(parameter.get());
   }
-  out_ << " : \n";
+  out_ << ") : (";
-  for (auto& argument_type : node->argument_types) {
+  Visit(node->type.get());
-    Visitor::Visit(argument_type);
+  out_ << ")\n";
+}
+
+void PrintVisitor::Visit(FunctionDefinitionStatement* node) {
+  out_ << "[Function] (";
+  Visit(node->definition.get());
+  out_ << ") = (";
+  Visitor::Visit(node->value);
+  out_ << ")\n";
+}
+
+void PrintVisitor::Visit(TypeDefinitionStatement* node) {
+  out_ << "[Type ";
+  switch (node->modifier) {
+    case TypeDefinitionStatement::Struct:
+    out_ << "struct";
+    break;
+    case TypeDefinitionStatement::Class:
+    out_ << "class";
+    break;
   }
-  out_ << ")\n";
+  out_ << "] (";
-}
+  Visit(node->definition.get());
-
+  out_ << ") = (";
-void PrintVisitor::Visit(FunctionDefinition* node) {
-  out_ << "(Function ";
-  Visit(node->name.get());
-  out_ << " = ";
   Visitor::Visit(node->value);
   out_ << ")\n";
 }
 
-void PrintVisitor::Visit(AliasTypeDefinition* node) {
+void PrintVisitor::Visit(AbstractTypeDefinitionStatement* node) {
-  out_ << "(AliasType ";
+  out_ << "[AbstractType ";
-  Visit(node->type.get());
+  switch (node->modifier) {
-  out_ << " = ";
+    case AbstractTypeDefinitionStatement::Basic:
-  Visit(node->value.get());
+    out_ << "basic";
+    break;
+    case AbstractTypeDefinitionStatement::Abstract:
+    out_ << "abstract";
+    break;
+  }
+  out_ << "] (";
+  Visit(node->definition.get());
   out_ << ")\n";
 }
 
-void PrintVisitor::Visit(TypeDefinition* node) {
+void PrintVisitor::Visit(TypeclassDefinitionStatement* node) {
-  out_ << "(Type ";
+  out_ << "[Typeclass] (";
-  Visit(node->type.get());
+  Visit(node->definition.get());
-  out_ << " = ";
-  Visitor::Visit(node->value);
-  out_ << ")\n";
-}
-
-void PrintVisitor::Visit(TypeclassDefinition* node) {
-  out_ << "(Typeclass ";
-  Visit(node->typeclass.get());
   if (!node->requirements.empty()) {
-    out_ << " : \n";
+    out_ << ") : (\n";
   }
   for (auto& requirement : node->requirements) {
     out_ << "& ";
     Visit(requirement.get());
+    out_ << "\n";
   }
   out_ << ")\n";
 }
 
 // Definition parts
 
-void PrintVisitor::Visit(DefinedName* node) {
+void PrintVisitor::Visit(FunctionDefinition* node) {
-  out_ << "(DefinedName ";
+  out_ << "[FunctionDefinition ";
-  Visit(&node->name);
+  switch (node->modifier) {
-  if (!node->parameters.empty()) {
+    case FunctionDefinition::Operator:
-    out_ << "\n";
+    out_ << "operator";
+    break;
+    case FunctionDefinition::Function:
+    out_ << "function";
+    break;
   }
-  for (auto& parameter : node->parameters) {
+  out_ << ' ';
-    Visit(parameter.get());
+  Visit(&node->name);
+  out_ << "]";
+  if (!node->parameters.empty()) {
+    out_ << " (";
+    for (auto& parameter : node->parameters) {
+      Visit(parameter.get());
+    }
+    out_ << ')';
   }
   if (!node->arguments.empty()) {
-    out_ << " : \n";
+    out_ << " : (";
+    for (auto& argument : node->arguments) {
+      Visit(&argument);
+    }
+    out_ << ')';
   }
-  for (auto& argument : node->arguments) {
+  out_ << ' ';
-    Visit(argument.get());
-  }
-  out_ << ")";
 }
 
-void PrintVisitor::Visit(DefinedAnnotatedName* node) {
+void PrintVisitor::Visit(TypeDefinition* node) {
-  out_ << "(DefinedAnnotatedName ";
+  out_ << "[TypeDefinition] (";
-  Visit(&node->name);
-  out_ << " : ";
-  if (std::holds_alternative<std::unique_ptr<DefinedType>>(node->type)) {
-    Visit(std::get<std::unique_ptr<DefinedType>>(node->type).get());
-  } else if (std::holds_alternative<std::unique_ptr<DefinedTypeclass>>(node->type)) {
-    Visit(std::get<std::unique_ptr<DefinedTypeclass>>(node->type).get());
-  } else {
-    // no annotation
-  }
-  out_ << " )";
-}
-
-void PrintVisitor::Visit(DefinedType* node) {
-  out_ << "(DefinedType ";
   Visit(node->type.get());
+  out_ << ')';
   if (!node->parameters.empty()) {
-    out_ << "\n";
+    out_ << '(';
+    for (auto& parameter : node->parameters) {
+      Visit(parameter.get());
+    }
+    out_ << ')';
   }
-  for (auto& parameter : node->parameters) {
+  out_ << ' ';
-    Visit(parameter.get());
-  }
-  if (!node->arguments.empty()) {
-    out_ << " : \n";
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-  }
-  out_ << ")";
-}
-
-void PrintVisitor::Visit(DefinedTypeclass* node) {
-  out_ << "(DefinedTypeclass ";
-  Visit(node->typeclass.get());
-  if (!node->parameters.empty()) {
-    out_ << "\n";
-  }
-  for (auto& parameter : node->parameters) {
-    Visit(parameter.get());
-  }
-  if (!node->arguments.empty()) {
-    out_ << " : \n";
-  }
-  for (auto& argument : node->arguments) {
-    Visit(argument.get());
-  }
-  out_ << ")";
 }
 
 void PrintVisitor::Visit(DefinitionParameter* node) {
-  out_ << "(DefinitionParameter " << (!node->typeclasses.empty() > 0 ? "(" : "");
+  out_ << "[DefinitionParameter ";
   Visit(&node->type);
-  out_ << ' ';
+  out_ << ']';
-  for (auto& typeclass : node->typeclasses) {
+  if (!node->typeclasses.empty() > 0) {
-    Visit(typeclass.get());
+    out_ << " (";
+    for (auto& typeclass : node->typeclasses) {
+      Visitor::Visit(typeclass);
+    }
+    out_ << ')';
   }
-  out_ << ")";
-}
-
-void PrintVisitor::Visit(DefinitionArgument* node) {
-  out_ << "(DefinitionArgument " << (!node->types.empty() ? "(" : "");
-  Visit(&node->name);
   out_ << ' ';
-  for (auto& type : node->types) {
-    Visit(type.get());
-  }
-  out_ << ")";
 }
 
 // Flow control -----------------
 
 void PrintVisitor::Visit(MatchCase* node) {
-  out_ << "(MatchCase | ";
+  out_ << "[MatchCase | ";
   Visitor::Visit(node->value);
   if (node->condition.has_value()) {
     out_ << " ? ";
@@ -270,13 +270,13 @@ void PrintVisitor::Visit(MatchCase* node) {
     out_ << " -> ";
     Visitor::Visit(node->statement.value());
   }
-  out_ << ")\n";
+  out_ << "]\n";
 }
 
 void PrintVisitor::Visit(Match* node) {
-  out_ << "(Match ";
+  out_ << "[Match] (";
   Visitor::Visit(node->value);
-  out_ << " with\n";
+  out_ << ") [with] (\n";
   for (auto& match_case : node->matches) {
     Visit(&match_case);
   }
@@ -284,80 +284,80 @@ void PrintVisitor::Visit(Match* node) {
 }
 
 void PrintVisitor::Visit(Condition* node) {
-  out_ << "(If ";
+  out_ << "[If] (";
   Visitor::Visit(node->conditions[0]);
-  out_ << " then\n";
+  out_ << ") [then] (\n";
   Visitor::Visit(node->statements[0]);
-  out_ << '\n';
+  out_ << ')';
   for (size_t i = 1; i < node->conditions.size(); ++i) {
-      out_ << "elif ";
+      out_ << " [elif] (";
       Visitor::Visit(node->conditions[i]);
-      out_ << " then\n";
+      out_ << ") [then] (\n";
       Visitor::Visit(node->statements[i]);
-      out_ << '\n';
+      out_ << ')';
   }
   if (node->statements.size() > node->conditions.size()) {
-    out_ << "else ";
+    out_ << " [else] (\n";
     Visitor::Visit(node->statements[node->conditions.size()]);
-    out_ << '\n';
+    out_ << ')';
   }
-  out_ << ")\n";
+  out_ << '\n';
 }
 
 void PrintVisitor::Visit(DoWhileLoop* node) {
-  out_ << "(DoWhile\n";
+  out_ << "[Do] (\n";
   Visitor::Visit(node->statement);
-  out_ << "\nwhile\n";
+  out_ << ") [while] (";
   Visitor::Visit(node->condition);
-  out_ << "\n)\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(WhileLoop* node) {
-  out_ << "(While\n";
+  out_ << "[While] (";
   Visitor::Visit(node->statement);
-  out_ << "\ndo\n";
+  out_ << ") [do] (\n";
   Visitor::Visit(node->condition);
-  out_ << "\n)\n";
+  out_ << ")\n";
 }
 void PrintVisitor::Visit(ForLoop* node) {
-  out_ << "(For\n";
+  out_ << "[For] (";
   Visitor::Visit(node->variable);
-  out_ << "\nin\n";
+  out_ << ") [in] (";
   Visitor::Visit(node->interval);
-  out_ << "\ndo\n";
+  out_ << ") [do] (\n";
   Visitor::Visit(node->statement);
   out_ << ")\n";
 }
 
 void PrintVisitor::Visit(LoopLoop* node) {
-  out_ << "(Loop\n";
+  out_ << "[Loop] (\n";
   Visitor::Visit(node->statement);
-  out_ << "\nLoop)\n";
+  out_ << ")\n";
 }
 
 // Statements, expressions, blocks, etc. -----------------
 
 void PrintVisitor::Visit(Block* node) {
-  out_ << "(Block {\n";
+  out_ << "[Block] {\n";
   for (auto& statement : node->statements) {
     Visitor::Visit(statement);
   }
-  out_ << "} )\n";
+  out_ << "}\n";
 }
 
 void PrintVisitor::Visit(ScopedStatement* node) {
-  out_ << "(Scoped ( ";
+  out_ << "[Scoped] ( ";
   Visitor::Visit(node->statement);
-  out_ << " ) )\n";
+  out_ << ")\n";
 }
 
 void PrintVisitor::Visit(LoopControlExpression& node) { // enum
   switch (node) {
     case LoopControlExpression::Break:
-      out_ << "(Break/>\n";
+      out_ << "[Break]\n";
       break;
     case LoopControlExpression::Continue:
-      out_ << "(Continue/>\n";
+      out_ << "[Continue]\n";
       break;
   }
 }
@@ -365,84 +365,119 @@ void PrintVisitor::Visit(LoopControlExpression& node) { // enum
 // Operators
 
 void PrintVisitor::Visit(BinaryOperatorExpression* node) {
-  out_ << "(BinaryOperator ";
+  out_ << "[BinaryOperator] (";
   Visitor::Visit(node->left_expression);
-  out_ << ' ';
+  out_ << ") [";
   Visit(&node->operator_name);
-  out_ << ' ';
+  out_ << "] (";
   Visitor::Visit(node->right_expression);
-  out_ << " )";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(UnaryOperatorExpression* node) {
-  out_ << "(UnaryOperator ";
+  out_ << "[UnaryOperator ";
   Visit(&node->operator_name);
-  out_ << ' ';
+  out_ << "] (";
   Visitor::Visit(node->expression);
-  out_ << " )";
+  out_ << ')';
 }
 
-// Simple Expressions
+void PrintVisitor::Visit(ReferenceExpression* node) {
+  out_ << "[ReferenceExpression ";
+  for (auto& reference : node->references) {
+    switch (reference) {
+      case ReferenceType::Reference:
+      out_ << '~';
+      break;
+      case ReferenceType::UniqueReference:
+      out_ << '@';
+      break;
+    }
+  }
+  out_ << "] (";
+  Visit(node->expression.get());
+  out_ << ')';
+}
+
+// Other Expressions
 
 void PrintVisitor::Visit(FunctionCallExpression* node) {
-  out_ << "(FunctionCall ";
+  out_ << "[FunctionCall ";
   Visit(node->name.get());
-  out_ << ' ';
+  out_ << "] (";
   for (auto& argument : node->arguments) {
     Visitor::Visit(argument);
-    out_ << ' ';
+    out_ << ", ";
   }
   out_ << ")\n";
 }
 
 void PrintVisitor::Visit(TupleExpression* node) {
-  out_ << "(TupleExpression ";
+  out_ << "[TupleExpression] (";
-  out_ << ' ';
   for (auto& expression : node->expressions) {
-    out_ << "& ";
+    out_ << "&";
     Visitor::Visit(expression);
   }
-  out_ << " )\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(VariantExpression* node) {
-  out_ << "(VariantExpression ";
+  out_ << "[VariantExpression] (";
-  out_ << ' ';
   for (auto& expression : node->expressions) {
-    out_ << "& ";
+    out_ << "|";
     Visitor::Visit(expression);
   }
-  out_ << " )\n";
+  out_ << ")";
 }
 
 void PrintVisitor::Visit(ReturnExpression* node) {
-  out_ << "(Return ";
+  out_ << "[Return] (";
   Visitor::Visit(node->expression);
-  out_ << " )\n";
+  out_ << ")\n";
 }
 
-// Lambda
+void PrintVisitor::Visit(TypeConstructor* node) {
+  out_ << "[TypeConstructor ";
+  Visit(node->type.get());
+  out_ << "]\n(";
+  for (auto& parameter : node->parameters) {
+    Visit(&parameter.first);
+    out_ << " = ";
+    Visitor::Visit(parameter.second);
+    out_ << ")\n(";
+  }
+  out_ << ")\n";
+}
 
 void PrintVisitor::Visit(LambdaFunction* node) {
-  out_ << "(LambdaFunction \\ ";
+  out_ << "[LambdaFunction] (";
   for (auto& parameter : node->parameters) {
     Visit(parameter.get());
   }
   if (!node->parameters.empty()) {
-    out_ << " : ";
+    out_ << ") : (";
   }
   for (auto& argument : node->arguments) {
-    Visit(argument.get());
+    Visit(&argument);
   }
-  out_ << " -> ";
+  out_ << ") -> (\n";
   Visitor::Visit(node->expression);
-  out_ << " )\n";
+  out_ << ")\n";
+}
+
+void PrintVisitor::Visit(ArrayExpression* node) {
+  out_ << "[ArrayExpression] ([";
+  for (auto& element : node->elements) {
+    Visitor::Visit(element);
+    out_ << ';';
+  }
+  out_ << "])";
 }
 
 // Name
 
-void PrintVisitor::Visit(NameSuperExpression* node) {
+void PrintVisitor::Visit(NameExpression* node) {
-  out_ << "(NameSuperExpression ";
+  out_ << "[NameExpression] (";
   for (auto& variable_namespace : node->namespaces) {
     Visitor::Visit(variable_namespace);
     out_ << '.';
@@ -453,191 +488,183 @@ void PrintVisitor::Visit(NameSuperExpression* node) {
       out_ << '.';
     }
   }
-  out_ << ")";
+  out_ << ')';
-}
-
-void PrintVisitor::Visit(NameExpression* node) {
-  out_ << "(NameExpression ";
-  for (auto& variable_namespace : node->namespaces) {
-    Visitor::Visit(variable_namespace);
-    out_ << '.';
-  }
-  for (size_t i = 0; i < node->names.size(); ++i) {
-    Visit(&node->names[i]);
-    if (i + 1 < node->names.size()) {
-      out_ << '.';
-    }
-  }
-  out_ << ")";
 }
 
 void PrintVisitor::Visit(TupleName* node) {
-  out_ << "(TupleName ";
+  out_ << "[TupleName] (";
   for (auto& name : node->names) {
-    out_ << '&';
+    out_ << "& ";
-    Visit(name.get());
+    Visitor::Visit(name);
   }
-  out_ << ")";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(VariantName* node) {
-  out_ << "(VariantName ";
+  out_ << "[VariantName] (";
   for (auto& name : node->names) {
-    out_ << '|';
+    out_ << "| ";
-    Visit(name.get());
+    Visitor::Visit(name);
   }
-  out_ << ")";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(AnnotatedName* node) {
-  out_ << "(AnnotatedName ";
+  out_ << "[AnnotatedName ";
   Visit(&node->name);
+  out_ << ']';
   if (node->type.has_value()) {
-    out_ << " : ";
+    out_ << " : (";
-    Visit(node->type.value().get());
+    Visitor::Visit(node->type.value());
+    out_ << ')';
   }
-  out_ << " )";
 }
 
+// Type, typeclass, etc. -----------------
+
 // Type
 
-void PrintVisitor::Visit(TypeConstructor* node) {
+void PrintVisitor::Visit(FunctionType* node) {
-  out_ << "(TypeConstructor ";
+  out_ << "[FunctionType] (";
-  Visit(node->type.get());
+  bool first = true;
-  out_ << '\n';
+  for (auto& type : node->types) {
-  for (auto& parameter : node->parameters) {
+    if (!first) {
-    Visit(&parameter.first);
+      out_ << " -> ";
-    out_ << " = ";
+    }
-    Visitor::Visit(parameter.second);
+    first = false;
-    out_ << '\n';
+    Visitor::Visit(type);
   }
-  out_ << ")";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(TupleType* node) {
-  out_ << "(TupleType ";
+  out_ << "[TupleType ";
   if (node->type.has_value()) {
     Visit(&node->type.value());
   }
-  out_ << ' ';
+  out_ << "] (";
   for (auto& entity : node->entities) {
     out_ << "& ";
     if (entity.first.has_value()) {
       Visit(&entity.first.value());
       out_ << " : ";
     }
-    Visitor::Visit(entity.second);
+    Visit(entity.second.get());
   }
-  out_ << ")";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(VariantType* node) {
-  out_ << "(VariantType ";
+  out_ << "[VariantType ";
   if (node->type.has_value()) {
     Visit(&node->type.value());
   }
-  out_ << ' ';
+  out_ << "] (";
   for (auto& constructor : node->constructors) {
     out_ << "| ";
-    if (std::holds_alternative<TypeIdentifierDefinition>(constructor)) {
+    if (std::holds_alternative<Constructor>(constructor)) {
-      Visit(&std::get<TypeIdentifierDefinition>(constructor));
+      Visit(&std::get<Constructor>(constructor));
     } else if (std::holds_alternative<std::unique_ptr<TupleType>>(constructor)) {
       Visit(std::get<std::unique_ptr<TupleType>>(constructor).get());
     } else {
       // error
     }
   }
-  out_ << ")";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(AnnotatedType* node) {
-  out_ << "(AnnotatedType ";
+  out_ << "[AnnotatedType ";
   Visit(node->type_expression.get());
+  out_ << ']';
   if (!node->annotations.empty()) {
-    out_ << " :";
+    out_ << " : (";
+    for (auto& annotation : node->annotations) {
+      Visitor::Visit(annotation);
+    }
+    out_ << ')';
   }
-  for (auto& annotation : node->annotations) {
-    out_ << " ";
-    Visit(annotation.get());
-  }
-  out_ << ")";
 }
 
 void PrintVisitor::Visit(ParametrizedType* node) {
-  out_ << "(ParametrizedType ";
+  out_ << "[ParametrizedType] (";
   Visit(node->type_expression.get());
   for (auto& parameter : node->parameters) {
     out_ << ' ';
     Visitor::Visit(parameter);
   }
-  out_ << " )";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(TypeExpression* node) {
-  out_ << "(TypeExpression ";
+  out_ << "[TypeExpression] (";
   for (auto& type_namespace : node->namespaces) {
     Visitor::Visit(type_namespace);
     out_ << '.';
   }
   Visit(&node->type);
-  out_ << " )";
+  out_ << ')';
+}
+
+void PrintVisitor::Visit(ExtendedScopedAnyType* node) {
+  out_ << "[ExtendedScopedAnyType ";
+  for (auto& reference : node->references) {
+    switch (reference) {
+      case ReferenceType::Reference:
+      out_ << '~';
+      break;
+      case ReferenceType::UniqueReference:
+      out_ << '@';
+      break;
+    }
+  }
+  out_ << "] (";
+  Visitor::Visit(node->type);
+  out_ << ')';
 }
 
 // Typeclass
 
-void PrintVisitor::Visit(AnnotatedTypeclass* node) {
-  out_ << "(AnnotatedTypeclass ";
-  Visit(node->typeclass_expression.get());
-  if (!node->annotations.empty()) {
-    out_ << " :";
-  }
-  for (auto& annotation : node->annotations) {
-    out_ << " ";
-    Visit(annotation.get());
-  }
-  out_ << ")";
-}
-
 void PrintVisitor::Visit(ParametrizedTypeclass* node) {
-  out_ << "(ParametrizedTypeclass ";
+  out_ << "[ParametrizedTypeclass] (";
   Visit(node->typeclass_expression.get());
   for (auto& paramater : node->parameters) {
     out_ << ' ';
     Visitor::Visit(paramater);
   }
-  out_ << " )";
+  out_ << ')';
 }
 
 void PrintVisitor::Visit(TypeclassExpression* node) {
-  out_ << "(TypeclassExpression ";
+  out_ << "[TypeclassExpression] (";
   for (auto& typeclass_namespace : node->namespaces) {
     Visitor::Visit(typeclass_namespace);
     out_ << '.';
   }
   Visit(&node->typeclass);
-  out_ << " )";
+  out_ << ')';
 }
 
 // Identifiers, constants, etc. -----------------
 
 void PrintVisitor::Visit(AnyIdentifier* node) { // std::string
-  out_ << "(Identifier " << *node << " )";
+  out_ << "[Identifier " << *node << "] ";
 }
 
 void PrintVisitor::Visit(FloatNumberLiteral* node) {
-  out_ << "(FloatNumber " << node->value << " )";
+  out_ << "[FloatNumber " << node->value << "] ";
 }
 
 void PrintVisitor::Visit(NumberLiteral* node) {
-  out_ << "(Number " << node->value << " )";
+  out_ << "[Number " << node->value << "] ";
 }
 
 void PrintVisitor::Visit(StringLiteral* node) {
-  out_ << "(String " << node->value << " )";
+  out_ << "[String " << node->value << "] ";
 }
 
 void PrintVisitor::Visit(CharLiteral* node) {
-  out_ << "(Char " << node->value << " )";
+  out_ << "[Char " << node->value << "] ";
 }
 
 } // namespace interpreter