diff --git a/.clang-format b/.clang-format
index deb0b18..f9f2c5e 100644
--- a/.clang-format
+++ b/.clang-format
@@ -33,8 +33,8 @@ ContinuationIndentWidth:	2
 AlignAfterOpenBracket: AlwaysBreak
 AlignConsecutiveDeclarations:
   Enabled:         true
-  AcrossEmptyLines: true
-  AcrossComments:  true
+  AcrossEmptyLines: false
+  AcrossComments:  false
   AlignCompound:   true
   PadOperators:    true
 AlignConsecutiveMacros:
diff --git a/compiler/ast/ast.cpp b/compiler/ast/ast.cpp
index 41559cf..610689c 100644
--- a/compiler/ast/ast.cpp
+++ b/compiler/ast/ast.cpp
@@ -80,8 +80,8 @@ namespace swallow::compiler::type
     Manager     typeManager;
     Environment typeEnvironment;
 
-    auto        intType = Type::Ptr(new Base("Int"));
-    auto        binopType =
+    auto intType = Type::Ptr(new Base("Int"));
+    auto binopType =
       Type::Ptr(new Arrow(intType, Type::Ptr(new type::Arrow(intType, intType))));
 
     typeEnvironment.Bind("+", binopType);
diff --git a/compiler/ast/ast.hpp b/compiler/ast/ast.hpp
index 1cb01a0..d63d1fd 100644
--- a/compiler/ast/ast.hpp
+++ b/compiler/ast/ast.hpp
@@ -44,29 +44,37 @@
 
 namespace swallow::compiler::ast
 {
+
+  /** The base class of expressions */
   class AST
   {
+
   public:
+    using Ptr = std::unique_ptr<AST>;
+
+    /** The location of the current expression in the source file.
+     * (generated by Bison, passed in parser.y) */
     const yy::location Location;
-    type::Type::Ptr    NodeType;
 
-    using Ptr = std::unique_ptr<AST>;
+    type::Type::Ptr NodeType;
 
     explicit AST(const yy::location Location) : Location(Location) {}
 
     virtual ~AST() = default;
 
+    /** This function calls TypeCheck,
+     * stores the result in NodeType and returns NodeType */
     auto CommonTypeCheck(
-      type::Manager &typeManager, const type::Environment &typeEnvironment) noexcept
-      -> type::Type::Ptr;
+      type::Manager           &typeManager,
+      const type::Environment &typeEnvironment) noexcept -> type::Type::Ptr;
 
-    void         CommonResolve(const type::Manager &typeManager) noexcept;
+    void CommonResolve(const type::Manager &typeManager) noexcept;
 
     virtual void Resolve(const type::Manager &typeManager) noexcept = 0;
 
-    virtual auto TypeCheck(
-      type::Manager &typeManager, const type::Environment &typeEnvironment) const noexcept
-      -> utils::Result<type::Type::Ptr, utils::Void> = 0;
+    virtual auto
+      TypeCheck(type::Manager &typeManager, const type::Environment &typeEnvironment)
+        const noexcept -> utils::Result<type::Type::Ptr, utils::Void> = 0;
 
     virtual void Dump(uint8_t indent, std::ostream &to) const noexcept = 0;
 
@@ -322,8 +330,8 @@ namespace swallow::compiler::ast
     const AST::Ptr                                       Body;
     std::vector<gmachine::instruction::Instruction::Ptr> Instructions;
 
-    std::vector<type::Type::Ptr>                         ParamTypes;
-    type::Type::Ptr                                      ReturnType;
+    std::vector<type::Type::Ptr> ParamTypes;
+    type::Type::Ptr              ReturnType;
 
     Fn(
       const yy::location       Location,
diff --git a/compiler/ast/g-machine.cpp b/compiler/ast/g-machine.cpp
index d4e7471..d59a901 100644
--- a/compiler/ast/g-machine.cpp
+++ b/compiler/ast/g-machine.cpp
@@ -57,7 +57,7 @@ namespace swallow::compiler::ast
     into.push_back(Instruction::Ptr(
       machineEnvironment->HasVariable(ID)
         ? dynamic_cast<Instruction *>(
-          new instruction::Push(machineEnvironment->GetOffset(ID).value()))
+            new instruction::Push(machineEnvironment->GetOffset(ID).value()))
 
         : dynamic_cast<Instruction *>(new instruction::PushGlobal(ID))));
   }
@@ -129,7 +129,7 @@ namespace swallow::compiler::ast
       constructorPattern->Params.rend(),
       [&](const auto &param) {
       newEnvironment = Environment::Ptr(new Variable(param, newEnvironment));
-      });
+    });
 
     branchInstructions.push_back(Instruction::Ptr(new instruction::Split()));
     branch->Expr->Compile(newEnvironment, branchInstructions);
diff --git a/compiler/ast/type.cpp b/compiler/ast/type.cpp
index 751ce85..88bdc49 100644
--- a/compiler/ast/type.cpp
+++ b/compiler/ast/type.cpp
@@ -43,16 +43,14 @@ using namespace swallow::compiler::utils;
 namespace swallow::compiler::ast
 {
 
-  auto Int::TypeCheck(
-    type::Manager &typeManager, const type::Environment &typeEnvironment) const noexcept
-    -> Result<type::Type::Ptr, Void>
+  auto Int::TypeCheck(type::Manager &typeManager, const type::Environment &typeEnvironment)
+    const noexcept -> Result<type::Type::Ptr, Void>
   {
     return Ok(type::Type::Ptr(new type::Base("Int")));
   }
 
-  auto LID::TypeCheck(
-    type::Manager &typeManager, const type::Environment &typeEnvironment) const noexcept
-    -> Result<type::Type::Ptr, Void>
+  auto LID::TypeCheck(type::Manager &typeManager, const type::Environment &typeEnvironment)
+    const noexcept -> Result<type::Type::Ptr, Void>
   {
     return typeEnvironment.Lookup(ID).or_else([&](const auto &err) {
       return diagnostics::Reporter::REPORTER->normal(
@@ -64,9 +62,8 @@ namespace swallow::compiler::ast
     });
   }
 
-  auto UID::TypeCheck(
-    type::Manager &typeManager, const type::Environment &typeEnvironment) const noexcept
-    -> Result<type::Type::Ptr, Void>
+  auto UID::TypeCheck(type::Manager &typeManager, const type::Environment &typeEnvironment)
+    const noexcept -> Result<type::Type::Ptr, Void>
   {
     return typeEnvironment.Lookup(ID).or_else([&](const auto &err) {
       return diagnostics::Reporter::REPORTER->normal(
@@ -78,27 +75,25 @@ namespace swallow::compiler::ast
     });
   }
 
-  auto Binop::TypeCheck(
-    type::Manager &typeManager, const type::Environment &typeEnvironment) const noexcept
-    -> Result<type::Type::Ptr, Void>
+  auto
+    Binop::TypeCheck(type::Manager &typeManager, const type::Environment &typeEnvironment)
+      const noexcept -> Result<type::Type::Ptr, Void>
   {
     const std::string operatorName = OperatorToString(Operator);
 
-    type::Type::Ptr   leftType = Left->CommonTypeCheck(typeManager, typeEnvironment);
-    type::Type::Ptr   rightType = Right->CommonTypeCheck(typeManager, typeEnvironment);
+    type::Type::Ptr leftType = Left->CommonTypeCheck(typeManager, typeEnvironment);
+    type::Type::Ptr rightType = Right->CommonTypeCheck(typeManager, typeEnvironment);
 
-    type::Type::Ptr   functionType =
-      typeEnvironment.Lookup(operatorName)
-        .or_else([&](const auto &err) {
-          return diagnostics::Reporter::REPORTER->normal(
-            Location,
-            std::format("'{}' was not declared", operatorName),
-            "The definition of this operator cannot be found in the "
-            "context",
-            "Operator is undefined",
-            diagnostics::BINOP_NOT_DECLARED);
-        })
-        .unwrap();
+    type::Type::Ptr functionType = typeEnvironment.Lookup(operatorName)
+                                     .or_else([&](const auto &err) {
+      return diagnostics::Reporter::REPORTER->normal(
+        Location,
+        std::format("'{}' was not declared", operatorName),
+        "The definition of this operator cannot be found in the "
+        "context",
+        "Operator is undefined",
+        diagnostics::BINOP_NOT_DECLARED);
+    }).unwrap();
 
     type::Type::Ptr returnType = typeManager.NewType();
     type::Type::Ptr arrowOne = type::Type::Ptr(new type::Arrow(rightType, returnType));
@@ -106,25 +101,24 @@ namespace swallow::compiler::ast
 
     typeManager.Unify(arrowTwo, functionType)
       .or_else([&](const auto &err) {
-        std::stringstream expected;
-        std::stringstream actual;
+      std::stringstream expected;
+      std::stringstream actual;
 
-        functionType->Dump(typeManager, expected);
-        arrowOne->Dump(typeManager, actual);
+      functionType->Dump(typeManager, expected);
+      arrowOne->Dump(typeManager, actual);
 
-        return diagnostics::Reporter::REPORTER->normal(
-          Location,
-          std::format("Type checking failed for '{}'", operatorName),
-          std::format(
-            "The operator '{}' has type '{}', but here may need a "
-            "'{}'",
-            operatorName,
-            expected.str(),
-            actual.str()),
-          std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
-          diagnostics::BINOP_TYPE_MISMATCH);
-      })
-      .ignore();
+      return diagnostics::Reporter::REPORTER->normal(
+        Location,
+        std::format("Type checking failed for '{}'", operatorName),
+        std::format(
+          "The operator '{}' has type '{}', but here may need a "
+          "'{}'",
+          operatorName,
+          expected.str(),
+          actual.str()),
+        std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
+        diagnostics::BINOP_TYPE_MISMATCH);
+    }).ignore();
 
     return Ok(returnType);
   }
@@ -141,30 +135,29 @@ namespace swallow::compiler::ast
 
     typeManager.Unify(arrowType, leftType)
       .or_else([&](const auto &err) {
-        std::stringstream expected;
-        std::stringstream actual;
+      std::stringstream expected;
+      std::stringstream actual;
 
-        arrowType->Dump(typeManager, expected);
-        leftType->Dump(typeManager, actual);
+      arrowType->Dump(typeManager, expected);
+      leftType->Dump(typeManager, actual);
 
-        return diagnostics::Reporter::REPORTER->normal(
-          Location,
-          std::format("Type checking failed for function application"),
-          std::format(
-            "This expression has type '{}', but here may need a '{}'",
-            actual.str(),
-            expected.str()),
-          std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
-          diagnostics::APPLICATION_TYPE_MISMATCH);
-      })
-      .ignore();
+      return diagnostics::Reporter::REPORTER->normal(
+        Location,
+        std::format("Type checking failed for function application"),
+        std::format(
+          "This expression has type '{}', but here may need a '{}'",
+          actual.str(),
+          expected.str()),
+        std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
+        diagnostics::APPLICATION_TYPE_MISMATCH);
+    }).ignore();
 
     return Ok(returnType);
   }
 
-  auto Match::TypeCheck(
-    type::Manager &typeManager, const type::Environment &typeEnvironment) const noexcept
-    -> Result<type::Type::Ptr, Void>
+  auto
+    Match::TypeCheck(type::Manager &typeManager, const type::Environment &typeEnvironment)
+      const noexcept -> Result<type::Type::Ptr, Void>
   {
     type::Variable *var = nullptr;
     type::Type::Ptr matchType =
@@ -181,23 +174,22 @@ namespace swallow::compiler::ast
 
         typeManager.Unify(branchType, currentBranchType)
           .or_else([&](const auto &err) {
-            std::stringstream expected;
-            std::stringstream actual;
-
-            branchType->Dump(typeManager, expected);
-            currentBranchType->Dump(typeManager, actual);
-
-            return diagnostics::Reporter::REPORTER->normal(
-              branch->Location,
-              "Type checking failed for Match expression's branch",
-              std::format(
-                "This branch has type '{}', but here may need a '{}'",
-                actual.str(),
-                expected.str()),
-              std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
-              diagnostics::MATCH_EXPR_BRANCHE_TYPE_CONFLICTS);
-          })
-          .ignore();
+          std::stringstream expected;
+          std::stringstream actual;
+
+          branchType->Dump(typeManager, expected);
+          currentBranchType->Dump(typeManager, actual);
+
+          return diagnostics::Reporter::REPORTER->normal(
+            branch->Location,
+            "Type checking failed for Match expression's branch",
+            std::format(
+              "This branch has type '{}', but here may need a '{}'",
+              actual.str(),
+              expected.str()),
+            std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
+            diagnostics::MATCH_EXPR_BRANCHE_TYPE_CONFLICTS);
+        }).ignore();
       }
 
     matchType = typeManager.Resolve(matchType, var);
@@ -227,18 +219,16 @@ namespace swallow::compiler::ast
     type::Manager     &typeManager,
     type::Environment &typeEnvironment) const noexcept
   {
-    type::Type::Ptr constructorType =
-      typeEnvironment.Lookup(ConstructorName)
-        .or_else([&](const auto &err) {
-          return diagnostics::Reporter::REPORTER->normal(
-            Location,
-            std::format("'{}' was not declared", ConstructorName),
-            "The definition of this constructor cannot be found in the "
-            "context",
-            "Constructor is undefined",
-            diagnostics::CONSTRUCTOR_NOT_DECLARED);
-        })
-        .unwrap();
+    type::Type::Ptr constructorType = typeEnvironment.Lookup(ConstructorName)
+                                        .or_else([&](const auto &err) {
+      return diagnostics::Reporter::REPORTER->normal(
+        Location,
+        std::format("'{}' was not declared", ConstructorName),
+        "The definition of this constructor cannot be found in the "
+        "context",
+        "Constructor is undefined",
+        diagnostics::CONSTRUCTOR_NOT_DECLARED);
+    }).unwrap();
 
     std::for_each(Params.begin(), Params.end(), [&](const std::string &param) {
       auto *arrow = dynamic_cast<type::Arrow *>(constructorType.get());
@@ -259,23 +249,22 @@ namespace swallow::compiler::ast
 
     typeManager.Unify(type, constructorType)
       .or_else([&](const auto &err) {
-        std::stringstream expected;
-        std::stringstream actual;
+      std::stringstream expected;
+      std::stringstream actual;
 
-        type->Dump(typeManager, expected);
-        constructorType->Dump(typeManager, actual);
+      type->Dump(typeManager, expected);
+      constructorType->Dump(typeManager, actual);
 
-        return diagnostics::Reporter::REPORTER->normal(
-          Location,
-          "Type checking failed for pattern",
-          std::format(
-            "This pattern has type '{}', but here may need a '{}'",
-            actual.str(),
-            expected.str()),
-          std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
-          diagnostics::PATTERN_MISMATCH);
-      })
-      .ignore();
+      return diagnostics::Reporter::REPORTER->normal(
+        Location,
+        "Type checking failed for pattern",
+        std::format(
+          "This pattern has type '{}', but here may need a '{}'",
+          actual.str(),
+          expected.str()),
+        std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
+        diagnostics::PATTERN_MISMATCH);
+    }).ignore();
   }
 
   void Fn::PreScanTypes(
@@ -298,8 +287,8 @@ namespace swallow::compiler::ast
   {
     type::Environment newEnvironment = typeEnvironment.Scope();
 
-    auto              paramIterator = Params.begin();
-    auto              typeIterator = ParamTypes.rbegin();
+    auto paramIterator = Params.begin();
+    auto typeIterator = ParamTypes.rbegin();
     while (paramIterator != Params.end() && typeIterator != ParamTypes.rend())
       {
         newEnvironment.Bind(*paramIterator, *typeIterator);
@@ -311,23 +300,22 @@ namespace swallow::compiler::ast
 
     typeManager.Unify(ReturnType, bodyType)
       .or_else([&](const auto &err) {
-        std::stringstream expected;
-        std::stringstream actual;
+      std::stringstream expected;
+      std::stringstream actual;
 
-        ReturnType->Dump(typeManager, expected);
-        bodyType->Dump(typeManager, actual);
+      ReturnType->Dump(typeManager, expected);
+      bodyType->Dump(typeManager, actual);
 
-        return diagnostics::Reporter::REPORTER->normal(
-          Location,
-          "Type checking failed for function",
-          std::format(
-            "This function has type '{}', but the body has type '{}'",
-            expected.str(),
-            actual.str()),
-          std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
-          diagnostics::MATCH_EXPR_BRANCHE_TYPE_CONFLICTS);
-      })
-      .ignore();
+      return diagnostics::Reporter::REPORTER->normal(
+        Location,
+        "Type checking failed for function",
+        std::format(
+          "This function has type '{}', but the body has type '{}'",
+          expected.str(),
+          actual.str()),
+        std::format("'{}' conflicts with '{}'", expected.str(), actual.str()),
+        diagnostics::MATCH_EXPR_BRANCHE_TYPE_CONFLICTS);
+    }).ignore();
   }
 
   void Data::PreScanTypes(
@@ -349,7 +337,7 @@ namespace swallow::compiler::ast
           [&](const auto &typeName) {
           fullType = type::Type::Ptr(
             new type::Arrow(type::Type::Ptr(new type::Base(typeName)), fullType));
-          });
+        });
 
         typeEnvironment.Bind(constructor->Name, fullType);
       }
@@ -360,19 +348,18 @@ namespace swallow::compiler::ast
   {}
 
   auto AST::CommonTypeCheck(
-    type::Manager &typeManager, const type::Environment &typeEnvironment) noexcept
-    -> type::Type::Ptr
+    type::Manager           &typeManager,
+    const type::Environment &typeEnvironment) noexcept -> type::Type::Ptr
   {
     NodeType = TypeCheck(typeManager, typeEnvironment)
                  .or_else([&](const auto &err) {
-                   return diagnostics::Reporter::REPORTER->normal(
-                     Location,
-                     "Type checking failed",
-                     "Wrong type here",
-                     std::format("No more information"),
-                     diagnostics::EXPR_TYPE_CHECKING_FAILED);
-                 })
-                 .unwrap();
+      return diagnostics::Reporter::REPORTER->normal(
+        Location,
+        "Type checking failed",
+        "Wrong type here",
+        std::format("No more information"),
+        diagnostics::EXPR_TYPE_CHECKING_FAILED);
+    }).unwrap();
     ;
     return NodeType;
   }
diff --git a/compiler/compiler.h b/compiler/compiler.h
index a457fb8..5dc2d87 100644
--- a/compiler/compiler.h
+++ b/compiler/compiler.h
@@ -39,8 +39,8 @@ namespace swallow::compiler
   class CompileUnit
   {
   public:
-    const std::string          FileValue;
-    const std::string          FilePath;
+    const std::string FileValue;
+    const std::string FilePath;
 
     inline static CompileUnit *FILE = nullptr;
 
diff --git a/compiler/diagnostics/diagnostics.cpp b/compiler/diagnostics/diagnostics.cpp
index 0a8aed5..e557d30 100644
--- a/compiler/diagnostics/diagnostics.cpp
+++ b/compiler/diagnostics/diagnostics.cpp
@@ -329,7 +329,7 @@ namespace swallow::compiler::diagnostics
       {
         const auto &line_span = this->details_->get_line_spans()[line_index];
 
-        auto        line_number = line_index + 1;
+        auto line_number = line_index + 1;
         output << "  "
                << COLOR_RGB(
                     std::setw(spaces_prefix.length() - 3)
@@ -368,7 +368,7 @@ namespace swallow::compiler::diagnostics
           }
       }
 
-    const auto                     &current_labels = level_labels.at(current_level);
+    const auto &current_labels = level_labels.at(current_level);
 
     std::map<size_t, const Label *> current_label_startings;
     for (const auto &label : current_labels)
@@ -475,7 +475,7 @@ namespace swallow::compiler::diagnostics
   void LabelGroup::print_colored_source_line(
     std::ostream &output, const Span &label_span, const Labels &labels) const
   {
-    const auto                      source = this->details_->get_line_source(label_span);
+    const auto source = this->details_->get_line_source(label_span);
 
     std::map<size_t, const Label *> mapped_labels;
     for (const auto &label : labels)
@@ -529,7 +529,7 @@ namespace swallow::compiler::diagnostics
 
     std::vector<Labels> level_labels;
 
-    auto                current_labels = descending_labels;
+    auto current_labels = descending_labels;
     while (true)
       {
         auto overlapping_labels = find_remove_overlapping_labels(current_labels);
@@ -549,7 +549,7 @@ namespace swallow::compiler::diagnostics
     if (labels.empty())
       return {};
 
-    Labels      overlapping_labels;
+    Labels overlapping_labels;
 
     const auto *current_label = labels.front();
     for (auto iterator = labels.begin() + 1; iterator < labels.end(); iterator++)
@@ -572,7 +572,7 @@ namespace swallow::compiler::diagnostics
 
   auto LabelGroup::find_labels_in_line(size_t line_index) const -> Labels
   {
-    Labels      result;
+    Labels result;
 
     const auto &line_span = this->details_->get_line_spans().at(line_index);
     for (const auto &label : this->labels_)
@@ -600,7 +600,7 @@ namespace swallow::compiler::diagnostics
     std::vector<Labels> labels_collection;
     auto               *current_labels = &labels_collection.emplace_back();
 
-    auto                ascending_labels(labels);
+    auto ascending_labels(labels);
     std::sort(ascending_labels.begin(), ascending_labels.end(), AscendingLabels());
 
     auto last_line = labels.front()->get_line();
diff --git a/compiler/diagnostics/diagnostics.h b/compiler/diagnostics/diagnostics.h
index a5dd4f8..05e1de1 100644
--- a/compiler/diagnostics/diagnostics.h
+++ b/compiler/diagnostics/diagnostics.h
@@ -65,7 +65,7 @@ namespace swallow::compiler::diagnostics
 
     [[nodiscard]] auto get_end_index() const -> size_t;
 
-    void               set_end_index(size_t end_index);
+    void set_end_index(size_t end_index);
 
     [[nodiscard]] auto get_width() const -> size_t;
 
@@ -133,8 +133,8 @@ namespace swallow::compiler::diagnostics
 
     [[nodiscard]] auto get_label_line(const Label &label) const -> size_t;
 
-    [[nodiscard]] auto get_line_spans() const
-      -> const std::vector<std::shared_ptr<Span>> &;
+    [[nodiscard]] auto
+      get_line_spans() const -> const std::vector<std::shared_ptr<Span>> &;
 
     [[nodiscard]] auto get_source() const -> const std::string &;
 
@@ -165,20 +165,20 @@ namespace swallow::compiler::diagnostics
     auto print_colored_source_line(
       std::ostream &output, const Span &label_span, const Labels &labels) const -> void;
 
-    [[nodiscard]] static auto find_label_levels(const Labels &labels)
-      -> std::vector<Labels>;
+    [[nodiscard]] static auto
+      find_label_levels(const Labels &labels) -> std::vector<Labels>;
 
     [[nodiscard]] static auto find_remove_overlapping_labels(Labels &labels) -> Labels;
 
-    [[nodiscard]] auto        find_labels_in_line(size_t line_index) const -> Labels;
+    [[nodiscard]] auto find_labels_in_line(size_t line_index) const -> Labels;
 
-    [[nodiscard]] auto        get_first_label() const -> const Label *;
+    [[nodiscard]] auto get_first_label() const -> const Label *;
 
-    [[nodiscard]] auto        get_labels() const -> const Labels &;
+    [[nodiscard]] auto get_labels() const -> const Labels &;
 
-    [[nodiscard]] auto        get_details() const -> Details *;
+    [[nodiscard]] auto get_details() const -> Details *;
 
-    [[nodiscard]] auto        get_last_label() const -> const Label *;
+    [[nodiscard]] auto get_last_label() const -> const Label *;
 
   private:
     const Label *first_label_;
@@ -215,7 +215,7 @@ namespace swallow::compiler::diagnostics
       std::vector<Label>         labels,
       std::optional<std::string> note);
 
-    auto               print(std::ostream &output) const -> void;
+    auto print(std::ostream &output) const -> void;
 
     [[nodiscard]] auto find_file_groups() const -> std::vector<FileGroup>;
 
diff --git a/compiler/g-machine/environment.cpp b/compiler/g-machine/environment.cpp
index 6af5193..0cd46b2 100644
--- a/compiler/g-machine/environment.cpp
+++ b/compiler/g-machine/environment.cpp
@@ -33,8 +33,8 @@
 namespace swallow::compiler::gmachine
 {
 
-  [[nodiscard]] auto Variable::GetOffset(const std::string &name) const noexcept
-    -> tl::optional<int>
+  [[nodiscard]] auto
+    Variable::GetOffset(const std::string &name) const noexcept -> tl::optional<int>
   {
     if (name == Name)
       return tl::make_optional(0);
@@ -64,8 +64,8 @@ namespace swallow::compiler::gmachine
     return false;
   }
 
-  [[nodiscard]] auto Offset::GetOffset(const std::string &name) const noexcept
-    -> tl::optional<int>
+  [[nodiscard]] auto
+    Offset::GetOffset(const std::string &name) const noexcept -> tl::optional<int>
   {
     if (Parent != nullptr)
       return Parent->GetOffset(name).map(
diff --git a/compiler/g-machine/environment.hpp b/compiler/g-machine/environment.hpp
index af831c1..48d0afe 100644
--- a/compiler/g-machine/environment.hpp
+++ b/compiler/g-machine/environment.hpp
@@ -44,11 +44,11 @@ namespace swallow::compiler::gmachine
 
     virtual ~Environment() = default;
 
-    [[nodiscard]] virtual auto GetOffset(const std::string &name) const noexcept
-      -> tl::optional<int> = 0;
+    [[nodiscard]] virtual auto
+      GetOffset(const std::string &name) const noexcept -> tl::optional<int> = 0;
 
-    [[nodiscard]] virtual auto HasVariable(const std::string &name) const noexcept
-      -> bool = 0;
+    [[nodiscard]] virtual auto
+      HasVariable(const std::string &name) const noexcept -> bool = 0;
   };
 
   class Variable : public Environment
@@ -61,11 +61,11 @@ namespace swallow::compiler::gmachine
       : Name(std::move(Name)), Parent(std::move(Parent))
     {}
 
-    [[nodiscard]] auto GetOffset(const std::string &name) const noexcept
-      -> tl::optional<int> override;
+    [[nodiscard]] auto
+      GetOffset(const std::string &name) const noexcept -> tl::optional<int> override;
 
-    [[nodiscard]] auto HasVariable(const std::string &name) const noexcept
-      -> bool override;
+    [[nodiscard]] auto
+      HasVariable(const std::string &name) const noexcept -> bool override;
   };
 
   class Offset : public Environment
@@ -76,11 +76,11 @@ namespace swallow::compiler::gmachine
 
     Offset(uint32_t Value, Ptr Parent) : Value(Value), Parent(std::move(Parent)) {}
 
-    [[nodiscard]] auto GetOffset(const std::string &name) const noexcept
-      -> tl::optional<int> override;
+    [[nodiscard]] auto
+      GetOffset(const std::string &name) const noexcept -> tl::optional<int> override;
 
-    [[nodiscard]] auto HasVariable(const std::string &name) const noexcept
-      -> bool override;
+    [[nodiscard]] auto
+      HasVariable(const std::string &name) const noexcept -> bool override;
   };
 
 } // namespace swallow::compiler::gmachine
diff --git a/compiler/lexer/flex_lexer.cpp b/compiler/lexer/flex_lexer.cpp
index e9329be..a9a8c9f 100644
--- a/compiler/lexer/flex_lexer.cpp
+++ b/compiler/lexer/flex_lexer.cpp
@@ -120,7 +120,7 @@ typedef unsigned int       flex_uint32_t;
  * to BEGIN to return to the state.  The YYSTATE alias is for lex
  * compatibility.
  */
-#define YY_START              (((yy_start) -1) / 2)
+#define YY_START              (((yy_start) - 1) / 2)
 #define YYSTATE               YY_START
 /* Action number for EOF rule of a given start state. */
 #define YY_STATE_EOF(state)   (YY_END_OF_BUFFER + state + 1)
@@ -155,7 +155,7 @@ typedef struct yy_buffer_state *YY_BUFFER_STATE;
 typedef size_t yy_size_t;
 #endif
 
-extern int   yyleng;
+extern int yyleng;
 
 extern FILE *yyin, *yyout;
 
@@ -214,41 +214,41 @@ struct yy_buffer_state
   /* Size of input buffer in bytes, not including room for EOB
    * characters.
    */
-  int   yy_buf_size;
+  int yy_buf_size;
 
   /* Number of characters read into yy_ch_buf, not including EOB
    * characters.
    */
-  int   yy_n_chars;
+  int yy_n_chars;
 
   /* Whether we "own" the buffer - i.e., we know we created it,
    * and can realloc() it to grow it, and should free() it to
    * delete it.
    */
-  int   yy_is_our_buffer;
+  int yy_is_our_buffer;
 
   /* Whether this is an "interactive" input source; if so, and
    * if we're using stdio for input, then we want to use getc()
    * instead of fread(), to make sure we stop fetching input after
    * each newline.
    */
-  int   yy_is_interactive;
+  int yy_is_interactive;
 
   /* Whether we're considered to be at the beginning of a line.
    * If so, '^' rules will be active on the next match, otherwise
    * not.
    */
-  int   yy_at_bol;
+  int yy_at_bol;
 
-  int   yy_bs_lineno; /**< The line count. */
-  int   yy_bs_column; /**< The column count. */
+  int yy_bs_lineno; /**< The line count. */
+  int yy_bs_column; /**< The column count. */
 
   /* Whether to try to fill the input buffer when we reach the
    * end of it.
    */
-  int   yy_fill_buffer;
+  int yy_fill_buffer;
 
-  int   yy_buffer_status;
+  int yy_buffer_status;
 
 #define YY_BUFFER_NEW         0
 #define YY_BUFFER_NORMAL      1
@@ -285,19 +285,19 @@ static YY_BUFFER_STATE *yy_buffer_stack = NULL;  /**< Stack as an array. */
 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
 
 /* yy_hold_char holds the character lost when yytext is formed. */
-static char     yy_hold_char;
-static int      yy_n_chars; /* number of characters read into yy_ch_buf */
-int             yyleng;
+static char yy_hold_char;
+static int  yy_n_chars; /* number of characters read into yy_ch_buf */
+int         yyleng;
 
 /* Points to current character in buffer. */
-static char    *yy_c_buf_p = NULL;
-static int      yy_init = 0;  /* whether we need to initialize */
-static int      yy_start = 0; /* start state number */
+static char *yy_c_buf_p = NULL;
+static int   yy_init = 0;  /* whether we need to initialize */
+static int   yy_start = 0; /* start state number */
 
 /* Flag which is used to allow yywrap()'s to do buffer switches
  * instead of setting up a fresh yyin.  A bit of a hack ...
  */
-static int      yy_did_buffer_switch_on_eof;
+static int yy_did_buffer_switch_on_eof;
 
 void            yyrestart(FILE *input_file);
 void            yy_switch_to_buffer(YY_BUFFER_STATE new_buffer);
@@ -307,18 +307,18 @@ void            yy_flush_buffer(YY_BUFFER_STATE b);
 void            yypush_buffer_state(YY_BUFFER_STATE new_buffer);
 void            yypop_buffer_state(void);
 
-static void     yyensure_buffer_stack(void);
-static void     yy_load_buffer_state(void);
-static void     yy_init_buffer(YY_BUFFER_STATE b, FILE *file);
+static void yyensure_buffer_stack(void);
+static void yy_load_buffer_state(void);
+static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file);
 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER)
 
 YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size);
 YY_BUFFER_STATE yy_scan_string(const char *yy_str);
 YY_BUFFER_STATE yy_scan_bytes(const char *bytes, int len);
 
-void           *yyalloc(yy_size_t);
-void           *yyrealloc(void *, yy_size_t);
-void            yyfree(void *);
+void *yyalloc(yy_size_t);
+void *yyrealloc(void *, yy_size_t);
+void  yyfree(void *);
 
 #define yy_new_buffer yy_create_buffer
 #define yy_set_interactive(is_interactive)                                               \
@@ -347,14 +347,14 @@ void            yyfree(void *);
 #define YY_SKIP_YYWRAP
 typedef flex_uint8_t YY_CHAR;
 
-FILE                *yyin = NULL, *yyout = NULL;
+FILE *yyin = NULL, *yyout = NULL;
 
-typedef int          yy_state_type;
+typedef int yy_state_type;
 
-extern int           yylineno;
-int                  yylineno = 1;
+extern int yylineno;
+int        yylineno = 1;
 
-extern char         *yytext;
+extern char *yytext;
 #ifdef yytext_ptr
 #undef yytext_ptr
 #endif
@@ -390,7 +390,7 @@ static const flex_int16_t yy_accept[46] = {0,  0,  0,  26, 25, 1,  13, 14, 3,  2
                                            11, 20, 12, 1,  19, 6,  21, 24, 23, 23, 23, 23,
                                            23, 23, 7,  23, 23, 8,  23, 10, 9,  0};
 
-static const YY_CHAR      yy_ec[256] = {
+static const YY_CHAR yy_ec[256] = {
   0,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
   1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  2,  1,  1,  1,  1,  1,  1,  1,  3,  4,
   5,  6,  7,  8,  1,  9,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 1,  11, 1,  12, 13,
@@ -407,8 +407,8 @@ static const YY_CHAR      yy_ec[256] = {
   1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
   1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1};
 
-static const YY_CHAR      yy_meta[31] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
-                                         1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1};
+static const YY_CHAR yy_meta[31] = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1,
+                                    1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 1, 1};
 
 static const flex_int16_t yy_base[48] = {0,  0,  0,  51, 52, 48, 52, 52, 52, 52, 52, 36,
                                          52, 38, 52, 34, 0,  52, 52, 0,  29, 24, 27, 20,
@@ -440,8 +440,8 @@ static const flex_int32_t yy_rule_can_match_eol[26] = {
 static yy_state_type yy_last_accepting_state;
 static char         *yy_last_accepting_cpos;
 
-extern int           yy_flex_debug;
-int                  yy_flex_debug = 0;
+extern int yy_flex_debug;
+int        yy_flex_debug = 0;
 
 /* The intent behind this definition is that it'll catch
  * any uses of REJECT which flex missed.
@@ -482,36 +482,36 @@ static yy::location LOC;
 #define YY_EXTRA_TYPE void *
 #endif
 
-static int    yy_init_globals(void);
+static int yy_init_globals(void);
 
 /* Accessor methods to globals.
    These are made visible to non-reentrant scanners for convenience. */
 
-int           yylex_destroy(void);
+int yylex_destroy(void);
 
-int           yyget_debug(void);
+int yyget_debug(void);
 
-void          yyset_debug(int debug_flag);
+void yyset_debug(int debug_flag);
 
 YY_EXTRA_TYPE yyget_extra(void);
 
-void          yyset_extra(YY_EXTRA_TYPE user_defined);
+void yyset_extra(YY_EXTRA_TYPE user_defined);
 
-FILE         *yyget_in(void);
+FILE *yyget_in(void);
 
-void          yyset_in(FILE *_in_str);
+void yyset_in(FILE *_in_str);
 
-FILE         *yyget_out(void);
+FILE *yyget_out(void);
 
-void          yyset_out(FILE *_out_str);
+void yyset_out(FILE *_out_str);
 
-int           yyget_leng(void);
+int yyget_leng(void);
 
-char         *yyget_text(void);
+char *yyget_text(void);
 
-int           yyget_lineno(void);
+int yyget_lineno(void);
 
-void          yyset_lineno(int _line_number);
+void yyset_lineno(int _line_number);
 
 /* Macros after this point can all be overridden by user definitions in
  * section 1.
@@ -521,7 +521,7 @@ void          yyset_lineno(int _line_number);
 #ifdef __cplusplus
 extern "C" int yywrap(void);
 #else
-extern int                 yywrap(void);
+extern int yywrap(void);
 #endif
 #endif
 
@@ -543,7 +543,7 @@ static int yy_flex_strlen(const char *);
 #ifdef __cplusplus
 static int yyinput(void);
 #else
-static int                 input(void);
+static int input(void);
 #endif
 
 #endif
@@ -1057,8 +1057,8 @@ YY_DECL
           default:
             YY_FATAL_ERROR("fatal flex scanner internal error--no action found");
           } /* end of action switch */
-      }     /* end of scanning one token */
-  }         /* end of user's declarations */
+      } /* end of scanning one token */
+  } /* end of user's declarations */
 } /* end of yylex */
 
 /* yy_get_next_buffer - try to read in a new buffer
@@ -1121,7 +1121,7 @@ static int yy_get_next_buffer(void)
           /* just a shorter name for the current buffer */
           YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
 
-          int             yy_c_buf_p_offset = (int) ((yy_c_buf_p) -b->yy_ch_buf);
+          int yy_c_buf_p_offset = (int) ((yy_c_buf_p) -b->yy_ch_buf);
 
           if (b->yy_is_our_buffer)
             {
@@ -1233,8 +1233,8 @@ static yy_state_type yy_get_previous_state(void)
  */
 static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state)
 {
-  int     yy_is_jam;
-  char   *yy_cp = (yy_c_buf_p);
+  int   yy_is_jam;
+  char *yy_cp = (yy_c_buf_p);
 
   YY_CHAR yy_c = 1;
   if (yy_accept[yy_current_state])
@@ -1301,7 +1301,7 @@ static void yyunput(int c, char *yy_bp)
 #ifdef __cplusplus
 static int yyinput(void)
 #else
-static int                 input(void)
+static int input(void)
 #endif
 
 {
@@ -1759,34 +1759,34 @@ static void yynoreturn yy_fatal_error(const char *msg)
 /** Get the current line number.
  *
  */
-int        yyget_lineno(void) { return yylineno; }
+int yyget_lineno(void) { return yylineno; }
 
 /** Get the input stream.
  *
  */
-FILE      *yyget_in(void) { return yyin; }
+FILE *yyget_in(void) { return yyin; }
 
 /** Get the output stream.
  *
  */
-FILE      *yyget_out(void) { return yyout; }
+FILE *yyget_out(void) { return yyout; }
 
 /** Get the length of the current token.
  *
  */
-int        yyget_leng(void) { return yyleng; }
+int yyget_leng(void) { return yyleng; }
 
 /** Get the current token.
  *
  */
 
-char      *yyget_text(void) { return yytext; }
+char *yyget_text(void) { return yytext; }
 
 /** Set the current line number.
  * @param _line_number line number
  *
  */
-void       yyset_lineno(int _line_number) { yylineno = _line_number; }
+void yyset_lineno(int _line_number) { yylineno = _line_number; }
 
 /** Set the input stream. This does not discard the current
  * input buffer.
@@ -1794,13 +1794,13 @@ void       yyset_lineno(int _line_number) { yylineno = _line_number; }
  *
  * @see yy_switch_to_buffer
  */
-void       yyset_in(FILE *_in_str) { yyin = _in_str; }
+void yyset_in(FILE *_in_str) { yyin = _in_str; }
 
-void       yyset_out(FILE *_out_str) { yyout = _out_str; }
+void yyset_out(FILE *_out_str) { yyout = _out_str; }
 
-int        yyget_debug(void) { return yy_flex_debug; }
+int yyget_debug(void) { return yy_flex_debug; }
 
-void       yyset_debug(int _bdebug) { yy_flex_debug = _bdebug; }
+void yyset_debug(int _bdebug) { yy_flex_debug = _bdebug; }
 
 static int yy_init_globals(void)
 {
diff --git a/compiler/parser/bison_parser.cpp b/compiler/parser/bison_parser.cpp
index 09c557a..8b61eb4 100644
--- a/compiler/parser/bison_parser.cpp
+++ b/compiler/parser/bison_parser.cpp
@@ -506,13 +506,13 @@ namespace yy
   void parser::yypop_(int n) YY_NOEXCEPT { yystack_.pop(n); }
 
 #if YYDEBUG
-  std::ostream&            parser::debug_stream() const { return *yycdebug_; }
+  std::ostream& parser::debug_stream() const { return *yycdebug_; }
 
-  void                     parser::set_debug_stream(std::ostream& o) { yycdebug_ = &o; }
+  void parser::set_debug_stream(std::ostream& o) { yycdebug_ = &o; }
 
   parser::debug_level_type parser::debug_level() const { return yydebug_; }
 
-  void                     parser::set_debug_level(debug_level_type l) { yydebug_ = l; }
+  void parser::set_debug_level(debug_level_type l) { yydebug_ = l; }
 #endif // YYDEBUG
 
   parser::state_type parser::yy_lr_goto_state_(state_type yystate, int yysym)
@@ -538,22 +538,22 @@ namespace yy
 
   int parser::parse()
   {
-    int               yyn;
+    int yyn;
     /// Length of the RHS of the rule being reduced.
-    int               yylen = 0;
+    int yylen = 0;
 
     // Error handling.
-    int               yynerrs_ = 0;
-    int               yyerrstatus_ = 0;
+    int yynerrs_ = 0;
+    int yyerrstatus_ = 0;
 
     /// The lookahead symbol.
-    symbol_type       yyla;
+    symbol_type yyla;
 
     /// The locations where the error started and ended.
     stack_symbol_type yyerror_range[3];
 
     /// The return value of parse ().
-    int               yyresult;
+    int yyresult;
 
 #if YY_EXCEPTIONS
     try
diff --git a/compiler/parser/bison_parser.hpp b/compiler/parser/bison_parser.hpp
index 4500b9c..9cd213e 100644
--- a/compiler/parser/bison_parser.hpp
+++ b/compiler/parser/bison_parser.hpp
@@ -234,14 +234,14 @@ namespace yy
 
       /// Instantiate an empty \a T in here.
       /// Obsolete, use emplace.
-      template <typename T> T&       build() { return emplace<T>(); }
+      template <typename T> T& build() { return emplace<T>(); }
 
       /// Instantiate a \a T in here from \a t.
       /// Obsolete, use emplace.
-      template <typename T> T&       build(const T& t) { return emplace<T>(t); }
+      template <typename T> T& build(const T& t) { return emplace<T>(t); }
 
       /// Accessor to a built \a T.
-      template <typename T> T&       as() YY_NOEXCEPT { return *yyas_<T>(); }
+      template <typename T> T& as() YY_NOEXCEPT { return *yyas_<T>(); }
 
       /// Const accessor to a built \a T (for %printer).
       template <typename T> const T& as() const YY_NOEXCEPT { return *yyas_<T>(); }
@@ -254,7 +254,7 @@ namespace yy
       /// should not be the variant's responsibility.
       /// Swapping between built and (possibly) non-built is done with
       /// self_type::move ().
-      template <typename T> void     swap(self_type& that) YY_NOEXCEPT
+      template <typename T> void swap(self_type& that) YY_NOEXCEPT
       {
         std::swap(as<T>(), that.as<T>());
       }
@@ -293,7 +293,7 @@ namespace yy
       /// Non copyable.
       value_type(const self_type&);
       /// Non copyable.
-      self_type&               operator=(const self_type&);
+      self_type& operator=(const self_type&);
 #endif
 
       /// Accessor to raw memory as \a T.
@@ -368,7 +368,7 @@ namespace yy
         /// Strongest alignment constraints.
         long double yyalign_me_;
         /// A buffer large enough to store any of the semantic values.
-        char        yyraw_[size];
+        char yyraw_[size];
       };
     };
 
@@ -377,7 +377,7 @@ namespace yy
     typedef value_type semantic_type;
 
     /// Symbol locations.
-    typedef location   location_type;
+    typedef location location_type;
 
     /// Syntax errors thrown from user actions.
     struct syntax_error : std::runtime_error
@@ -437,7 +437,7 @@ namespace yy
     typedef token::token_kind_type token_kind_type;
 
     /// Backward compatibility alias (Bison 3.6).
-    typedef token_kind_type        token_type;
+    typedef token_kind_type token_type;
 
     /// Symbol kinds.
     struct symbol_kind
@@ -497,7 +497,7 @@ namespace yy
     typedef symbol_kind::symbol_kind_type symbol_kind_type;
 
     /// The number of tokens.
-    static const symbol_kind_type         YYNTOKENS = symbol_kind::YYNTOKENS;
+    static const symbol_kind_type YYNTOKENS = symbol_kind::YYNTOKENS;
 
     /// A complete symbol.
     ///
@@ -812,16 +812,16 @@ namespace yy
       symbol_kind_type type_get() const YY_NOEXCEPT;
 
       /// Whether empty.
-      bool             empty() const YY_NOEXCEPT;
+      bool empty() const YY_NOEXCEPT;
 
       /// Destructive move, \a s is emptied into this.
-      void             move(basic_symbol& s);
+      void move(basic_symbol& s);
 
       /// The semantic value.
-      value_type       value;
+      value_type value;
 
       /// The location.
-      location_type    location;
+      location_type location;
 
     private:
 #if YY_CPLUSPLUS < 201103L
@@ -851,10 +851,10 @@ namespace yy
       by_kind(kind_type t) YY_NOEXCEPT;
 
       /// Record that this symbol is empty.
-      void             clear() YY_NOEXCEPT;
+      void clear() YY_NOEXCEPT;
 
       /// Steal the symbol kind from \a that.
-      void             move(by_kind& that);
+      void move(by_kind& that);
 
       /// The (internal) type number (corresponding to \a type).
       /// \a empty when empty.
@@ -919,7 +919,7 @@ namespace yy
 
     /// Parse.  An alias for parse ().
     /// \returns  0 iff parsing succeeded.
-    int         operator()();
+    int operator()();
 
     /// Parse.
     /// \returns  0 iff parsing succeeded.
@@ -927,16 +927,16 @@ namespace yy
 
 #if YYDEBUG
     /// The current debugging stream.
-    std::ostream&    debug_stream() const YY_ATTRIBUTE_PURE;
+    std::ostream& debug_stream() const YY_ATTRIBUTE_PURE;
     /// Set the current debugging stream.
-    void             set_debug_stream(std::ostream&);
+    void set_debug_stream(std::ostream&);
 
     /// Type for debugging levels.
-    typedef int      debug_level_type;
+    typedef int debug_level_type;
     /// The current debugging level.
     debug_level_type debug_level() const YY_ATTRIBUTE_PURE;
     /// Set the current debugging level.
-    void             set_debug_level(debug_level_type l);
+    void set_debug_level(debug_level_type l);
 #endif
 
     /// Report a syntax error.
@@ -945,7 +945,7 @@ namespace yy
     virtual void error(const location_type& loc, const std::string& msg);
 
     /// Report a syntax error.
-    void         error(const syntax_error& err);
+    void error(const syntax_error& err);
 
 #if YYDEBUG || 0
     /// The user-facing name of the symbol whose (internal) number is
@@ -1250,20 +1250,20 @@ namespace yy
 #endif
 
     /// Stored state numbers (used for stacks).
-    typedef signed char      state_type;
+    typedef signed char state_type;
 
     /// Compute post-reduction state.
     /// \param yystate   the current state
     /// \param yysym     the nonterminal to push on the stack
-    static state_type        yy_lr_goto_state_(state_type yystate, int yysym);
+    static state_type yy_lr_goto_state_(state_type yystate, int yysym);
 
     /// Whether the given \c yypact_ value indicates a defaulted state.
     /// \param yyvalue   the value to check
-    static bool              yy_pact_value_is_default_(int yyvalue) YY_NOEXCEPT;
+    static bool yy_pact_value_is_default_(int yyvalue) YY_NOEXCEPT;
 
     /// Whether the given \c yytable_ value indicates a syntax error.
     /// \param yyvalue   the value to check
-    static bool              yy_table_value_is_error_(int yyvalue) YY_NOEXCEPT;
+    static bool yy_table_value_is_error_(int yyvalue) YY_NOEXCEPT;
 
     static const signed char yypact_ninf_;
     static const signed char yytable_ninf_;
@@ -1271,7 +1271,7 @@ namespace yy
     /// Convert a scanner token kind \a t to a symbol kind.
     /// In theory \a t should be a token_kind_type, but character literals
     /// are valid, yet not members of the token_kind_type enum.
-    static symbol_kind_type  yytranslate_(int t) YY_NOEXCEPT;
+    static symbol_kind_type yytranslate_(int t) YY_NOEXCEPT;
 
 #if YYDEBUG || 0
     /// For a symbol, its name in clear.
@@ -1315,14 +1315,14 @@ namespace yy
     // YYRLINE[YYN] -- Source line where rule number YYN was defined.
     static const unsigned char yyrline_[];
     /// Report on the debug stream that the rule \a r is going to be reduced.
-    virtual void               yy_reduce_print_(int r) const;
+    virtual void yy_reduce_print_(int r) const;
     /// Print the state stack on the debug stream.
-    virtual void               yy_stack_print_() const;
+    virtual void yy_stack_print_() const;
 
     /// Debugging level.
-    int                        yydebug_;
+    int yydebug_;
     /// Debug stream.
-    std::ostream*              yycdebug_;
+    std::ostream* yycdebug_;
 
     /// \brief Display a symbol kind, value and location.
     /// \param yyo    The output stream.
@@ -1355,10 +1355,10 @@ namespace yy
       by_state(const by_state& that) YY_NOEXCEPT;
 
       /// Record that this symbol is empty.
-      void             clear() YY_NOEXCEPT;
+      void clear() YY_NOEXCEPT;
 
       /// Steal the symbol kind from \a that.
-      void             move(by_state& that);
+      void move(by_state& that);
 
       /// The symbol kind (corresponding to \a state).
       /// \a symbol_kind::S_YYEMPTY when empty.
@@ -1425,12 +1425,12 @@ namespace yy
       /// Random access.
       ///
       /// Index 0 returns the topmost element.
-      T&       operator[](index_type i) { return seq_[size_type(size() - 1 - i)]; }
+      T& operator[](index_type i) { return seq_[size_type(size() - 1 - i)]; }
 
       /// Steal the contents of \a t.
       ///
       /// Close to move-semantics.
-      void     push(YY_MOVE_REF(T) t)
+      void push(YY_MOVE_REF(T) t)
       {
         seq_.push_back(T());
         operator[](0).move(t);
@@ -1444,10 +1444,10 @@ namespace yy
       }
 
       /// Pop all elements from the stack.
-      void           clear() YY_NOEXCEPT { seq_.clear(); }
+      void clear() YY_NOEXCEPT { seq_.clear(); }
 
       /// Number of elements on the stack.
-      index_type     size() const YY_NOEXCEPT { return index_type(seq_.size()); }
+      index_type size() const YY_NOEXCEPT { return index_type(seq_.size()); }
 
       /// Iterator on top of the stack (going downwards).
       const_iterator begin() const YY_NOEXCEPT { return seq_.begin(); }
@@ -1485,7 +1485,7 @@ namespace yy
     typedef stack<stack_symbol_type> stack_type;
 
     /// The stack.
-    stack_type                       yystack_;
+    stack_type yystack_;
 
     /// Push a new state on the stack.
     /// \param m    a debug message to display
diff --git a/compiler/parser/location.hh b/compiler/parser/location.hh
index 893daee..b5bd227 100644
--- a/compiler/parser/location.hh
+++ b/compiler/parser/location.hh
@@ -64,7 +64,7 @@ namespace yy
     /// Type for file name.
     typedef const std::string filename_type;
     /// Type for line and column numbers.
-    typedef int               counter_type;
+    typedef int counter_type;
 
     /// Construct a position.
     explicit position(
@@ -93,16 +93,16 @@ namespace yy
     }
 
     /// (column related) Advance to the COUNT next columns.
-    void           columns(counter_type count = 1) { column = add_(column, count, 1); }
+    void columns(counter_type count = 1) { column = add_(column, count, 1); }
 
     /** \} */
 
     /// File name to which this position refers.
     filename_type* filename;
     /// Current line number.
-    counter_type   line;
+    counter_type line;
     /// Current column number.
-    counter_type   column;
+    counter_type column;
 
   private:
     /// Compute max (min, lhs+rhs).
@@ -157,7 +157,7 @@ namespace yy
     /// Type for file name.
     typedef position::filename_type filename_type;
     /// Type for line and column numbers.
-    typedef position::counter_type  counter_type;
+    typedef position::counter_type counter_type;
 
     /// Construct a location from \a b to \a e.
     location(const position& b, const position& e) : begin(b), end(e) {}
@@ -206,7 +206,7 @@ namespace yy
   }
 
   /// Join two locations.
-  inline location  operator+(location res, const location& end) { return res += end; }
+  inline location operator+(location res, const location& end) { return res += end; }
 
   /// Add \a width columns to the end position, in place.
   inline location& operator+=(location& res, location::counter_type width)
diff --git a/compiler/parser/parser.cpp b/compiler/parser/parser.cpp
index 9d5d2b0..581f051 100644
--- a/compiler/parser/parser.cpp
+++ b/compiler/parser/parser.cpp
@@ -53,7 +53,7 @@ namespace yy
 
 extern std::vector<swallow::compiler::ast::Definition::Ptr> Program;
 
-extern FILE                                                *yyin, *yyout;
+extern FILE *yyin, *yyout;
 
 namespace swallow::compiler::parser
 {
diff --git a/compiler/type/environment.cpp b/compiler/type/environment.cpp
index 075d560..3584ce7 100644
--- a/compiler/type/environment.cpp
+++ b/compiler/type/environment.cpp
@@ -36,8 +36,8 @@ using namespace swallow::compiler::utils;
 namespace swallow::compiler::type
 {
 
-  auto Environment::Lookup(const std::string &name) const noexcept
-    -> Result<Type::Ptr, Void>
+  auto
+    Environment::Lookup(const std::string &name) const noexcept -> Result<Type::Ptr, Void>
   {
     if (const auto it = Names.find(name); it != Names.end())
       return Ok(it->second);
diff --git a/compiler/type/environment.hpp b/compiler/type/environment.hpp
index 1729f37..ee549d8 100644
--- a/compiler/type/environment.hpp
+++ b/compiler/type/environment.hpp
@@ -51,8 +51,8 @@ namespace swallow::compiler::type
 
     [[nodiscard]] auto Scope() const noexcept -> Environment;
 
-    void               Bind(const std::string &name, Type::Ptr type) noexcept;
-    void               Dump(std::ostream &to, const Manager &typeManager) noexcept;
+    void Bind(const std::string &name, Type::Ptr type) noexcept;
+    void Dump(std::ostream &to, const Manager &typeManager) noexcept;
   };
 
 } // namespace swallow::compiler::type
diff --git a/compiler/type/type.hpp b/compiler/type/type.hpp
index 728f4e9..b06ccf8 100644
--- a/compiler/type/type.hpp
+++ b/compiler/type/type.hpp
@@ -100,12 +100,12 @@ namespace swallow::compiler::type
     int32_t                          LastID = 0;
     std::map<std::string, Type::Ptr> Types;
 
-    auto                             NewTypeName() noexcept -> std::string;
-    auto                             NewType() noexcept -> Type::Ptr;
-    auto                             NewArrowType() noexcept -> Type::Ptr;
+    auto NewTypeName() noexcept -> std::string;
+    auto NewType() noexcept -> Type::Ptr;
+    auto NewArrowType() noexcept -> Type::Ptr;
 
     /** Find values for placeholder variables such that they can equal. */
-    auto                             Unify(Type::Ptr left, Type::Ptr right) noexcept
+    auto Unify(Type::Ptr left, Type::Ptr right) noexcept
       -> utils::Result<utils::Void, utils::Void>;
 
     /** Get to the bottom of a chain of equations. */
diff --git a/compiler/utils/optional/optional.hpp b/compiler/utils/optional/optional.hpp
index 6ab4e4d..54518f2 100644
--- a/compiler/utils/optional/optional.hpp
+++ b/compiler/utils/optional/optional.hpp
@@ -259,8 +259,8 @@ namespace tl
       struct tag
       {};
 
-      template <class T> tag                  swap(T &, T &);
-      template <class T, std::size_t N> tag   swap(T (&a)[N], T (&b)[N]);
+      template <class T> tag                swap(T &, T &);
+      template <class T, std::size_t N> tag swap(T (&a)[N], T (&b)[N]);
 
       // helper functions to test if an unqualified swap is possible, and if it
       // becomes std::swap
@@ -498,13 +498,13 @@ namespace tl
           }
       }
 
-      bool                              has_value() const { return this->m_has_value; }
+      bool has_value() const { return this->m_has_value; }
 
-      TL_OPTIONAL_11_CONSTEXPR T       &get()       &{ return this->m_value; }
+      TL_OPTIONAL_11_CONSTEXPR T &get() & { return this->m_value; }
 
       TL_OPTIONAL_11_CONSTEXPR const T &get() const & { return this->m_value; }
 
-      TL_OPTIONAL_11_CONSTEXPR T      &&get()      &&{ return std::move(this->m_value); }
+      TL_OPTIONAL_11_CONSTEXPR T &&get() && { return std::move(this->m_value); }
 #ifndef TL_OPTIONAL_NO_CONSTRR
       constexpr const T &&get() const && { return std::move(this->m_value); }
 #endif
@@ -610,9 +610,9 @@ namespace tl
 #ifndef TL_OPTIONAL_GCC49
     template <
       class T,
-      bool =
-        std::is_trivially_destructible<T>::value &&std::is_trivially_move_constructible<
-          T>::value &&std::is_trivially_move_assignable<T>::value>
+      bool = std::is_trivially_destructible<T>::value
+             && std::is_trivially_move_constructible<T>::value
+             && std::is_trivially_move_assignable<T>::value>
     struct optional_move_assign_base : optional_copy_assign_base<T>
     {
       using optional_copy_assign_base<T>::optional_copy_assign_base;
@@ -635,7 +635,7 @@ namespace tl
 
       optional_move_assign_base &operator=(optional_move_assign_base &&rhs) noexcept(
         std::is_nothrow_move_constructible<T>::value
-          &&std::is_nothrow_move_assignable<T>::value)
+        && std::is_nothrow_move_assignable<T>::value)
       {
         this->assign(std::move(rhs));
         return *this;
@@ -1377,8 +1377,9 @@ namespace tl
     /// If both have a value, the values are swapped.
     /// If one has a value, it is moved to the other and the movee is left
     /// valueless.
-    void swap(optional &rhs) noexcept(std::is_nothrow_move_constructible<T>::value
-                                        &&detail::is_nothrow_swappable<T>::value)
+    void swap(optional &rhs) noexcept(
+      std::is_nothrow_move_constructible<T>::value
+      && detail::is_nothrow_swappable<T>::value)
     {
       using std::swap;
       if (has_value())
@@ -1404,12 +1405,12 @@ namespace tl
     /// Returns a pointer to the stored value
     constexpr const T *operator->() const { return std::addressof(this->m_value); }
 
-    TL_OPTIONAL_11_CONSTEXPR T  *operator->() { return std::addressof(this->m_value); }
+    TL_OPTIONAL_11_CONSTEXPR T *operator->() { return std::addressof(this->m_value); }
 
     /// Returns the stored value
-    TL_OPTIONAL_11_CONSTEXPR T  &operator*()  &{ return this->m_value; }
+    TL_OPTIONAL_11_CONSTEXPR T &operator*() & { return this->m_value; }
 
-    constexpr const T           &operator*() const           &{ return this->m_value; }
+    constexpr const T &operator*() const & { return this->m_value; }
 
     TL_OPTIONAL_11_CONSTEXPR T &&operator*() && { return std::move(this->m_value); }
 
@@ -2243,7 +2244,7 @@ namespace tl
       return *this = std::forward<U>(u);
     }
 
-    void               swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); }
+    void swap(optional &rhs) noexcept { std::swap(m_value, rhs.m_value); }
 
     /// Returns a pointer to the stored value
     constexpr const T *operator->() const noexcept { return m_value; }
@@ -2253,9 +2254,9 @@ namespace tl
     /// Returns the stored value
     TL_OPTIONAL_11_CONSTEXPR T &operator*() noexcept { return *m_value; }
 
-    constexpr const T          &operator*() const noexcept { return *m_value; }
+    constexpr const T &operator*() const noexcept { return *m_value; }
 
-    constexpr bool              has_value() const noexcept { return m_value != nullptr; }
+    constexpr bool has_value() const noexcept { return m_value != nullptr; }
 
     constexpr explicit operator bool() const noexcept { return m_value != nullptr; }
 
diff --git a/compiler/utils/variadic-table/variadic_table.hpp b/compiler/utils/variadic-table/variadic_table.hpp
index eef068c..3c7a2ae 100644
--- a/compiler/utils/variadic-table/variadic_table.hpp
+++ b/compiler/utils/variadic-table/variadic_table.hpp
@@ -373,28 +373,28 @@ namespace swallow::compiler::utils::variadicTable
     }
 
     /// The column headers
-    std::vector<std::string>               _headers;
+    std::vector<std::string> _headers;
 
     /// Number of columns in the table
-    unsigned int                           _num_columns;
+    unsigned int _num_columns;
 
     /// Size of columns that we can't get the size of
-    unsigned int                           _static_column_size;
+    unsigned int _static_column_size;
 
     /// Size of the cell padding
-    unsigned int                           _cell_padding;
+    unsigned int _cell_padding;
 
     /// The actual data
-    std::vector<DataTuple>                 _data;
+    std::vector<DataTuple> _data;
 
     /// Holds the printable width of each column
-    std::vector<size_t>                    _column_sizes;
+    std::vector<size_t> _column_sizes;
 
     /// Column Format
     std::vector<VariadicTableColumnFormat> _column_format;
 
     /// Precision For each column
-    std::vector<int>                       _precision;
+    std::vector<int> _precision;
   };
 
 } // namespace swallow::compiler::utils::variadicTable