diff --git a/include/interpreter_tree.hpp b/include/interpreter_tree.hpp
index cad604d..b889888 100644
--- a/include/interpreter_tree.hpp
+++ b/include/interpreter_tree.hpp
@@ -451,19 +451,19 @@ using FunctionArgument = std::variant<
 
 struct FunctionCallExpression : public Node {
   std::unique_ptr<NameSuperExpression> name;
-  std::vector<std::unique_ptr<FunctionArgument>> arguments;
+  std::vector<FunctionArgument> arguments;
 };
 
 struct TupleExpression : public Node {
-  std::vector<std::unique_ptr<SubExpression>> expressions;
+  std::vector<SubExpression> expressions;
 };
 
 struct VariantExpression : public Node {
-  std::vector<std::unique_ptr<SubExpression>> expressions;
+  std::vector<SubExpression> expressions;
 };
 
 struct ReturnExpression : public Node {
-  std::unique_ptr<Expression> expression;
+  Expression expression;
 };
 
 // Lambda -----------------
@@ -471,14 +471,14 @@ struct ReturnExpression : public Node {
 struct LambdaFunction : public Node {
   std::vector<std::unique_ptr<DefinitionParameter>> parameters;
   std::vector<std::unique_ptr<DefinitionArgument>> arguments;
-  std::unique_ptr<Expression> expression;
+  Expression expression;
 };
 
 // Name -----------------
 
 struct NameSuperExpression : public Node {
-  std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
-  std::vector<std::unique_ptr<NameSubSuperExpression>> expressions; // last is not SuperExpression
+  std::vector<TypeSubExpression> namespaces;
+  std::vector<NameSubSuperExpression> expressions; // last is not SuperExpression
 };
 
 struct NameExpression : public Node {
@@ -505,12 +505,12 @@ struct AnnotatedName : public Node {
 
 struct TypeConstructor : public Node {
   std::unique_ptr<ParametrizedType> type;
-  std::vector<std::pair<NameIdentifier, std::unique_ptr<SubExpression>>> parameters;
+  std::vector<std::pair<NameIdentifier, SubExpression>> parameters;
 };
 
 struct TupleType : public Node {
   TypeIdentifierDefinition type; // optional
-  std::vector<std::pair<NameIdentifier, std::unique_ptr<AnyType>>> entities; // NameIdentifier is optional
+  std::vector<std::pair<NameIdentifier, AnyType>> entities; // NameIdentifier is optional
 };
 
 struct VariantType : public Node {
@@ -529,11 +529,11 @@ using TypeParameter = std::variant<
 
 struct ParametrizedType : public Node {
   std::unique_ptr<TypeExpression> type_expression;
-  std::vector<std::unique_ptr<TypeParameter>> parameters;
+  std::vector<TypeParameter> parameters;
 };
 
 struct TypeExpression : public Node {
-  std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
+  std::vector<TypeSubExpression> namespaces;
   AnyTypeIdentifier type;
 };
 
@@ -546,11 +546,11 @@ struct AnnotatedTypeclass : public Node {
 
 struct ParametrizedTypeclass : public Node {
     std::unique_ptr<TypeclassExpression> typeclass_expression;
-    std::vector<std::unique_ptr<TypeParameter>> parameters;
+    std::vector<TypeParameter> parameters;
 };
 
 struct TypeclassExpression : public Node {
-    std::vector<std::unique_ptr<TypeSubExpression>> namespaces;
+    std::vector<TypeSubExpression> namespaces;
     TypeclassIdentifier typeclass;
 };
 
diff --git a/src/print_visitor.cpp b/src/print_visitor.cpp
index aea8d0f..934ff8b 100644
--- a/src/print_visitor.cpp
+++ b/src/print_visitor.cpp
@@ -364,37 +364,228 @@ void PrintVisitor::Visit(UnaryOperatorExpression* node) {
 
 // Simple Expressions
 
-void PrintVisitor::Visit(FunctionCallExpression* node) {}
-void PrintVisitor::Visit(TupleExpression* node) {}
-void PrintVisitor::Visit(VariantExpression* node) {}
-void PrintVisitor::Visit(ReturnExpression* node) {}
+void PrintVisitor::Visit(FunctionCallExpression* node) {
+  out_ << "<FunctionCall> ";
+  Visit(node->name.get());
+  out_ << ' ';
+  for (auto& argument : node->arguments) {
+    Visitor::Visit(argument);
+    out_ << ' ';
+  }
+  out_ << "</FunctionCall>";
+}
+
+void PrintVisitor::Visit(TupleExpression* node) {
+  out_ << "<TupleExpression> ";
+  out_ << ' ';
+  for (auto& expression : node->expressions) {
+    out_ << "& ";
+    Visitor::Visit(expression);
+  }
+  out_ << " </TupleExpression>";
+}
+
+void PrintVisitor::Visit(VariantExpression* node) {
+  out_ << "<VariantExpression> ";
+  out_ << ' ';
+  for (auto& expression : node->expressions) {
+    out_ << "& ";
+    Visitor::Visit(expression);
+  }
+  out_ << " </VariantExpression>";
+}
+
+void PrintVisitor::Visit(ReturnExpression* node) {
+  out_ << "<Return> ";
+  Visitor::Visit(node->expression);
+  out_ << " </Return>";
+}
 
 // Lambda
 
-void PrintVisitor::Visit(LambdaFunction* node) {}
+void PrintVisitor::Visit(LambdaFunction* node) {
+  out_ << "<LambdaFunction> \\ ";
+  for (auto& parameter : node->parameters) {
+    Visit(parameter.get());
+  }
+  if (node->parameters.size() > 0) {
+    out_ << " : ";
+  }
+  for (auto& argument : node->arguments) {
+    Visit(argument.get());
+  }
+  out_ << " -> ";
+  Visitor::Visit(node->expression);
+  out_ << " </LambdaFunction>";
+}
 
 // Name
 
-void PrintVisitor::Visit(NameSuperExpression* node) {}
-void PrintVisitor::Visit(NameExpression* node) {}
-void PrintVisitor::Visit(TupleName* node) {}
-void PrintVisitor::Visit(VariantName* node) {}
-void PrintVisitor::Visit(AnnotatedName* node) {}
+void PrintVisitor::Visit(NameSuperExpression* node) {
+  out_ << "<NameSuperExpression> ";
+  for (auto& variable_namespace : node->namespaces) {
+    Visitor::Visit(variable_namespace);
+    out_ << '.';
+  }
+  for (int i = 0; i < node->expressions.size(); ++i) {
+    Visitor::Visit(node->expressions[i]);
+    if (i + 1 < node->expressions.size()) {
+      out_ << '.';
+    }
+  }
+  out_ << "</NameSupperExpression>\n";
+}
+
+void PrintVisitor::Visit(NameExpression* node) {
+  out_ << "<NameExpression> ";
+  for (auto& variable_namespace : node->namespaces) {
+    Visitor::Visit(variable_namespace);
+    out_ << '.';
+  }
+  for (int i = 0; i < node->names.size(); ++i) {
+    Visit(&node->names[i]);
+    if (i + 1 < node->names.size()) {
+      out_ << '.';
+    }
+  }
+  out_ << "</NameExpression>\n";
+}
+
+void PrintVisitor::Visit(TupleName* node) {
+  out_ << "<TupleName> ";
+  for (auto& name : node->names) {
+    out_ << '&';
+    Visit(name.get());
+  }
+  out_ << "</TupleName>\n";
+}
+
+void PrintVisitor::Visit(VariantName* node) {
+  out_ << "<VariantName> ";
+  for (auto& name : node->names) {
+    out_ << '|';
+    Visit(name.get());
+  }
+  out_ << "</VariantName>\n";
+}
+
+void PrintVisitor::Visit(AnnotatedName* node) {
+  out_ << "<AnnotatedName> ";
+  Visit(&node->name);
+  out_ << ' ';
+  Visit(node->type.get());
+  out_ << " </AnnotatedName>";
+}
 
 // Type
 
-void PrintVisitor::Visit(TypeConstructor* node) {}
-void PrintVisitor::Visit(TupleType* node) {}
-void PrintVisitor::Visit(VariantType* node) {}
-void PrintVisitor::Visit(AnnotatedType* node) {}
-void PrintVisitor::Visit(ParametrizedType* node) {}
-void PrintVisitor::Visit(TypeExpression* node) {}
+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_ << "</TypeConstructor>\n";
+}
+
+void PrintVisitor::Visit(TupleType* node) {
+  out_ << "<TupleType> ";
+  Visit(&node->type); // optional
+  out_ << ' ';
+  for (auto& entity : node->entities) {
+    out_ << "& ";
+    if (entity.first != "") {
+      Visit(&entity.first);
+      out_ << " : ";
+    }
+    Visitor::Visit(entity.second);
+  }
+  out_ << "</TupleType>";
+}
+
+void PrintVisitor::Visit(VariantType* node) {
+  out_ << "<VariantType> ";
+  Visit(&node->type); // optional
+  out_ << ' ';
+  for (auto& constructor : node->constructors) {
+    out_ << "| ";
+    Visit(&constructor.first);
+    Visit(constructor.second.get());
+  }
+  out_ << "</VariantType>";
+}
+
+void PrintVisitor::Visit(AnnotatedType* node) {
+  out_ << "<AnnotatedType> ";
+  Visit(node->type_expression.get());
+  if (node->annotations.size() > 0) {
+    out_ << " :";
+  }
+  for (auto& annotation : node->annotations) {
+    out_ << " ";
+    Visit(annotation.get());
+  }
+  out_ << "</AnnotatedType>";
+}
+
+void PrintVisitor::Visit(ParametrizedType* node) {
+  out_ << "<ParametrizedType> ";
+  Visit(node->type_expression.get());
+  for (auto& paramater : node->parameters) {
+    out_ << ' ';
+    Visitor::Visit(paramater);
+  }
+  out_ << " </ParamtrizedType>";
+}
+
+void PrintVisitor::Visit(TypeExpression* node) {
+  out_ << "<TypeExpression> ";
+  for (auto& type_namespace : node->namespaces) {
+    Visitor::Visit(type_namespace);
+    out_ << '.';
+  }
+  Visit(&node->type);
+  out_ << " </TypeExpression>";
+}
 
 // Typeclass
 
-void PrintVisitor::Visit(AnnotatedTypeclass* node) {}
-void PrintVisitor::Visit(ParametrizedTypeclass* node) {}
-void PrintVisitor::Visit(TypeclassExpression* node) {}
+void PrintVisitor::Visit(AnnotatedTypeclass* node) {
+  out_ << "<AnnotatedTypeclass> ";
+  Visit(node->typeclass_expression.get());
+  if (node->annotations.size() > 0) {
+    out_ << " :";
+  }
+  for (auto& annotation : node->annotations) {
+    out_ << " ";
+    Visit(annotation.get());
+  }
+  out_ << "</AnnotatedTypeclass>";
+}
+
+void PrintVisitor::Visit(ParametrizedTypeclass* node) {
+  out_ << "<ParametrizedTypeclass> ";
+  Visit(node->typeclass_expression.get());
+  for (auto& paramater : node->parameters) {
+    out_ << ' ';
+    Visitor::Visit(paramater);
+  }
+  out_ << " </ParamtrizedTypeclass>";
+}
+
+void PrintVisitor::Visit(TypeclassExpression* node) {
+  out_ << "<TypeclassExpression> ";
+  for (auto& typeclass_namespace : node->namespaces) {
+    Visitor::Visit(typeclass_namespace);
+    out_ << '.';
+  }
+  Visit(&node->typeclass);
+  out_ << " </TypeclassExpression>";
+}
 
 // Identifiers, constants, etc. -----------------