diff --git a/boot/ast.cc b/boot/ast.cc
index d3e0b9f..7e11cfd 100644
--- a/boot/ast.cc
+++ b/boot/ast.cc
@@ -17,175 +17,8 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/ast.h"
 
-namespace elna
+namespace elna::boot
 {
-namespace boot
-{
-    void empty_visitor::visit(variable_declaration *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(constant_definition *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(procedure_definition *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(type_definition *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(procedure_call *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(traits_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(cast_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(assign_statement *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(if_statement *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(while_statement *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(return_statement *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(defer_statement *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(block *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(program *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(binary_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(unary_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(primitive_type_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(array_type_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(pointer_type_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(record_type_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(union_type_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(procedure_type_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(variable_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(array_access_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(field_access_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(dereference_expression *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(number_literal<std::int32_t> *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(number_literal<std::uint32_t> *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(number_literal<double> *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(number_literal<bool> *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(number_literal<unsigned char> *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(number_literal<std::nullptr_t> *)
-    {
-        __builtin_unreachable();
-    }
-
-    void empty_visitor::visit(number_literal<std::string> *)
-    {
-        __builtin_unreachable();
-    }
-
     node::node(const struct position position)
         : source_position(position)
     {
@@ -305,7 +138,7 @@ namespace boot
         return nullptr;
     }
 
-    literal *expression::is_literal()
+    literal_expression *expression::is_literal()
     {
         return nullptr;
     }
@@ -336,7 +169,7 @@ namespace boot
         {
             return node->accept(visitor);
         }
-        else if (literal *node = is_literal())
+        else if (literal_expression *node = is_literal())
         {
             return node->accept(visitor);
         }
@@ -518,7 +351,7 @@ namespace boot
     }
 
     constant_definition::constant_definition(const struct position position, const std::string& identifier,
-            const bool exported, literal *body)
+            const bool exported, literal_expression *body)
         : definition(position, identifier, exported), m_body(body)
     {
     }
@@ -528,7 +361,7 @@ namespace boot
         visitor->visit(this);
     }
 
-    literal& constant_definition::body()
+    literal_expression& constant_definition::body()
     {
         return *m_body;
     }
@@ -538,14 +371,19 @@ namespace boot
         delete m_body;
     }
 
-    procedure_type_expression::procedure_type_expression(const struct position position,
-            std::shared_ptr<type_expression> return_type)
-        : type_expression(position), return_type(return_type), no_return(false)
+    return_declaration::return_declaration(std::shared_ptr<type_expression> type)
+        : type(type)
     {
     }
 
-    procedure_type_expression::procedure_type_expression(const struct position position, no_return_t)
-        : type_expression(position), return_type(nullptr), no_return(true)
+    return_declaration::return_declaration(std::monostate)
+        : no_return(true)
+    {
+    }
+
+    procedure_type_expression::procedure_type_expression(const struct position position,
+            return_declaration return_type)
+        : type_expression(position), return_type(return_type)
     {
     }
 
@@ -554,14 +392,6 @@ namespace boot
         visitor->visit(this);
     }
 
-    procedure_type_expression::~procedure_type_expression()
-    {
-        for (auto parameter : this->parameters)
-        {
-            delete parameter;
-        }
-    }
-
     procedure_definition::procedure_definition(const struct position position, const std::string& identifier,
             const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body)
         : definition(position, identifier, exported), m_heading(heading), body(body)
@@ -652,42 +482,42 @@ namespace boot
         }
     }
 
-    literal::literal()
+    literal_expression::literal_expression()
     {
     }
 
-    literal *literal::is_literal()
+    literal_expression *literal_expression::is_literal()
     {
         return this;
     }
 
-    void literal::accept(parser_visitor *visitor)
+    void literal_expression::accept(parser_visitor *visitor)
     {
-        if (number_literal<std::int32_t> *node = is_int())
+        if (literal<std::int32_t> *node = is_int())
         {
             return node->accept(visitor);
         }
-        else if (number_literal<std::uint32_t> *node = is_word())
+        else if (literal<std::uint32_t> *node = is_word())
         {
             return node->accept(visitor);
         }
-        else if (number_literal<double> *node = is_float())
+        else if (literal<double> *node = is_float())
         {
             return node->accept(visitor);
         }
-        else if (number_literal<bool> *node = is_bool())
+        else if (literal<bool> *node = is_bool())
         {
             return node->accept(visitor);
         }
-        else if (number_literal<unsigned char> *node = is_char())
+        else if (literal<unsigned char> *node = is_char())
         {
             return node->accept(visitor);
         }
-        else if (number_literal<std::nullptr_t> *node = is_nil())
+        else if (literal<std::nullptr_t> *node = is_nil())
         {
             return node->accept(visitor);
         }
-        else if (number_literal<std::string> *node = is_string())
+        else if (literal<std::string> *node = is_string())
         {
             return node->accept(visitor);
         }
@@ -991,9 +821,8 @@ namespace boot
         delete m_value;
     }
 
-    traits_expression::traits_expression(const struct position position,
-            const std::string& name, std::shared_ptr<type_expression> type)
-        : node(position), m_type(type), name(name)
+    traits_expression::traits_expression(const struct position position, const std::string& name)
+        : node(position), name(name)
     {
     }
 
@@ -1007,11 +836,6 @@ namespace boot
         return this;
     }
 
-    type_expression& traits_expression::type()
-    {
-        return *m_type;
-    }
-
     conditional_statements::conditional_statements(expression *prerequisite)
         : m_prerequisite(prerequisite)
     {
@@ -1212,4 +1036,3 @@ namespace boot
         __builtin_unreachable();
     };
 }
-}
diff --git a/boot/driver.cc b/boot/driver.cc
index 0257d44..eb1ad1d 100644
--- a/boot/driver.cc
+++ b/boot/driver.cc
@@ -17,9 +17,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/driver.h"
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     position make_position(const yy::location& location)
     {
@@ -79,4 +77,3 @@ namespace boot
         }
     }
 }
-}
diff --git a/boot/parser.yy b/boot/parser.yy
index 2959d2e..e146db4 100644
--- a/boot/parser.yy
+++ b/boot/parser.yy
@@ -87,7 +87,7 @@ along with GCC; see the file COPYING3.  If not see
     ARROW "->" EXCLAMATION "!"
     AT "@" HAT "^"
     COLON ":" SEMICOLON ";" DOT "." COMMA ","
-%token NOT "not"
+%token NOT "~"
     CAST "cast"
     NIL "nil"
     CONST "const"
@@ -107,27 +107,26 @@ along with GCC; see the file COPYING3.  If not see
     BEGIN_BLOCK "begin"
     END_BLOCK "end"
     DEFER "defer"
-%token OR "or" AND "and" XOR "xor"
+%token OR "|" AND "&" XOR "xor"
     EQUALS "=" NOT_EQUAL "<>" LESS_THAN "<" GREATER_THAN ">" LESS_EQUAL "<=" GREATER_EQUAL ">="
     SHIFT_LEFT "<<" SHIFT_RIGHT ">>"
     PLUS "+" MINUS "-"
     MULTIPLICATION "*" DIVISION "/" REMAINDER "%"
 
-%left "or" "and" "xor"
+%left "|" "&" "xor"
 %left "=" "<>" "<" ">" "<=" ">="
 %left "<<" ">>"
 %left "+" "-"
 %left "*" "/" "%"
 
-%type <elna::boot::literal *> literal;
+%type <elna::boot::literal_expression *> literal;
 %type <elna::boot::constant_definition *> constant_definition;
 %type <std::vector<elna::boot::constant_definition *>> constant_part constant_definitions;
-%type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part variable_declaration
-    formal_parameters formal_parameter_list;
-%type <elna::boot::variable_declaration *> formal_parameter
+%type <std::vector<elna::boot::variable_declaration *>> variable_declarations variable_part variable_declaration;
 %type <std::shared_ptr<elna::boot::type_expression>> type_expression;
+%type <std::vector<std::shared_ptr<elna::boot::type_expression>>> type_expressions;
 %type <elna::boot::traits_expression *> traits_expression;
-%type <elna::boot::expression *> expression operand;
+%type <elna::boot::expression *> expression operand qualident;
 %type <elna::boot::unary_expression *> unary_expression;
 %type <elna::boot::binary_expression *> binary_expression;
 %type <std::vector<elna::boot::expression *>> expressions actual_parameter_list;
@@ -140,14 +139,15 @@ along with GCC; see the file COPYING3.  If not see
 %type <elna::boot::statement *> statement;
 %type <std::vector<elna::boot::statement *>> statements;
 %type <elna::boot::procedure_definition *> procedure_definition;
-%type <std::shared_ptr<elna::boot::procedure_type_expression>> procedure_heading;
+%type <std::pair<std::vector<std::string>, std::shared_ptr<elna::boot::procedure_type_expression>>> procedure_heading;
+%type <elna::boot::return_declaration> return_declaration;
 %type <std::vector<elna::boot::procedure_definition *>> procedure_definitions procedure_part;
 %type <elna::boot::type_definition *> type_definition;
 %type <std::vector<elna::boot::type_definition *>> type_definitions type_part;
 %type <elna::boot::block *> block;
-%type <elna::boot::field_declaration> field_declaration;
+%type <elna::boot::field_declaration> field_declaration formal_parameter;
 %type <std::vector<std::pair<std::string, std::shared_ptr<elna::boot::type_expression>>>>
-    optional_fields required_fields;
+    optional_fields required_fields formal_parameters;
 %type <std::vector<elna::boot::conditional_statements *>> elsif_then_statements elsif_do_statements;
 %type <elna::boot::cast_expression *> cast_expression;
 %type <elna::boot::defer_statement *> defer_statement;
@@ -191,31 +191,32 @@ identifier_definitions:
             $$.emplace($$.cbegin(), $1);
         }
     | identifier_definition { $$.emplace_back(std::move($1)); }
+return_declaration:
+    /* proper procedure */ {}
+    | "->" "!" { $$ = elna::boot::return_declaration(std::monostate{}); }
+    | "->" type_expression { $$ = elna::boot::return_declaration($2); }
 procedure_heading:
-    formal_parameter_list
+    "(" formal_parameters ")" return_declaration
         {
-            $$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1));
-            std::swap($1, $$->parameters);
-        }
-    | formal_parameter_list "->" "!"
-        {
-            $$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
-                elna::boot::no_return);
-            std::swap($1, $$->parameters);
-        }
-    | formal_parameter_list "->" type_expression
-        {
-            $$ = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1), $3);
-            std::swap($1, $$->parameters);
+            $$.second = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
+                    std::move($4));
+            for (auto& [name, type] : $2)
+            {
+                $$.first.emplace_back(std::move(name));
+                $$.second->parameters.push_back(type);
+            }
         }
 procedure_definition:
     "proc" identifier_definition procedure_heading ";" block
         {
-            $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second, $3, $5);
+            $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1),
+                    $2.first, $2.second, $3.second, $5);
+            std::swap($3.first, $$->parameter_names);
         }
     | "proc" identifier_definition procedure_heading ";" "extern"
         {
-            $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second, $3);
+            $$ = new elna::boot::procedure_definition(elna::boot::make_position(@1), $2.first, $2.second, $3.second);
+            std::swap($3.first, $$->parameter_names);
         }
 procedure_definitions:
     procedure_definition procedure_definitions
@@ -293,47 +294,50 @@ defer_statement: DEFER statements "end"
 literal:
     INTEGER
         {
-            $$ = new elna::boot::number_literal<std::int32_t>(elna::boot::make_position(@1), $1);
+            $$ = new elna::boot::literal<std::int32_t>(elna::boot::make_position(@1), $1);
         }
     | WORD
         {
-            $$ = new elna::boot::number_literal<std::uint32_t>(elna::boot::make_position(@1), $1);
+            $$ = new elna::boot::literal<std::uint32_t>(elna::boot::make_position(@1), $1);
         }
     | FLOAT
         {
-            $$ = new elna::boot::number_literal<double>(elna::boot::make_position(@1), $1);
+            $$ = new elna::boot::literal<double>(elna::boot::make_position(@1), $1);
         }
     | BOOLEAN
         {
-            $$ = new elna::boot::number_literal<bool>(elna::boot::make_position(@1), $1);
+            $$ = new elna::boot::literal<bool>(elna::boot::make_position(@1), $1);
         }
     | CHARACTER
         {
-            $$ = new elna::boot::number_literal<unsigned char>(elna::boot::make_position(@1), $1.at(0));
+            $$ = new elna::boot::literal<unsigned char>(elna::boot::make_position(@1), $1.at(0));
         }
     | "nil"
         {
-            $$ = new elna::boot::number_literal<std::nullptr_t>(elna::boot::make_position(@1), nullptr);
+            $$ = new elna::boot::literal<std::nullptr_t>(elna::boot::make_position(@1), nullptr);
         }
     | STRING
         {
-            $$ = new elna::boot::number_literal<std::string>(elna::boot::make_position(@1), $1);
+            $$ = new elna::boot::literal<std::string>(elna::boot::make_position(@1), $1);
         }
 traits_expression:
-    TRAIT "(" type_expression ")"
+    TRAIT "(" type_expressions ")"
         {
-            $$ = new elna::boot::traits_expression(elna::boot::make_position(@1), $1, $3);
+            $$ = new elna::boot::traits_expression(elna::boot::make_position(@1), $1);
+            std::swap($3, $$->parameters);
         }
-operand:
+qualident:
     literal { $$ = $1; }
     | designator_expression { $$ = $1; }
     | traits_expression { $$ = $1; }
     | cast_expression { $$ = $1; }
     | call_expression { $$ = $1; }
     | "(" expression ")" { $$ = $2; }
-expression:
+operand:
     unary_expression { $$ = $1; }
-    | binary_expression { $$ = $1; }
+    | qualident { $$ = $1; }
+expression:
+    binary_expression { $$ = $1; }
     | operand { $$ = $1; }
 binary_expression:
     expression "*" expression
@@ -391,12 +395,12 @@ binary_expression:
             $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
                 elna::boot::binary_operator::greater_equal);
         }
-    | expression "and" expression
+    | expression "&" expression
         {
             $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
                 elna::boot::binary_operator::conjunction);
         }
-    | expression "or" expression
+    | expression "|" expression
         {
             $$ = new elna::boot::binary_expression(elna::boot::make_position(@2), $1, $3,
                 elna::boot::binary_operator::disjunction);
@@ -422,7 +426,7 @@ unary_expression:
             $$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2,
                 elna::boot::unary_operator::reference);
         }
-    | "not" operand
+    | "~" operand
         {
             $$ = new elna::boot::unary_expression(elna::boot::make_position(@1), $2,
                 elna::boot::unary_operator::negation);
@@ -438,17 +442,24 @@ expressions:
             std::swap($$, $3);
             $$.emplace($$.cbegin(), $1);
         }
-    | expression { $$.emplace_back(std::move($1)); }
+    | expression { $$.push_back($1); }
+type_expressions:
+    type_expression "," type_expressions
+        {
+            std::swap($$, $3);
+            $$.emplace($$.cbegin(), $1);
+        }
+    | type_expression { $$.push_back($1); }
 designator_expression:
-    operand "[" expression "]"
+    qualident "[" expression "]"
         {
             $$ = new elna::boot::array_access_expression(elna::boot::make_position(@2), $1, $3);
         }
-    | operand "." IDENTIFIER
+    | qualident "." IDENTIFIER
         {
             $$ = new elna::boot::field_access_expression(elna::boot::make_position(@2), $1, $3);
         }
-    | operand "^"
+    | qualident "^"
         {
             $$ = new elna::boot::dereference_expression(elna::boot::make_position(@1), $1);
         }
@@ -500,9 +511,12 @@ type_expression:
         {
             $$ = std::make_shared<elna::boot::union_type_expression>(elna::boot::make_position(@1), std::move($2));
         }
-    | "proc" procedure_heading
+    | "proc" "(" type_expressions ")" return_declaration
         {
-            $$ = $2;
+            auto result = std::make_shared<elna::boot::procedure_type_expression>(elna::boot::make_position(@1),
+                    std::move($5));
+            std::swap(result->parameters, $3);
+            $$ = result;
         }
     | IDENTIFIER
         {
@@ -559,18 +573,16 @@ type_part:
     | "type" type_definitions { std::swap($$, $2); }
 formal_parameter: IDENTIFIER ":" type_expression
         {
-            $$ = new elna::boot::variable_declaration(elna::boot::make_position(@2), $1, $3);
+            $$ = std::make_pair($1, $3);
         }
 formal_parameters:
-    formal_parameter "," formal_parameters
+    /* no formal parameters */ {}
+    | formal_parameter "," formal_parameters
         {
             std::swap($$, $3);
             $$.emplace($$.cbegin(), $1);
         }
     | formal_parameter { $$.emplace_back(std::move($1)); }
-formal_parameter_list:
-    "(" ")" {}
-    | "(" formal_parameters ")" { std::swap($$, $2); }
 actual_parameter_list:
     "(" ")" {}
     | "(" expressions ")" { std::swap($$, $2); }
diff --git a/boot/result.cc b/boot/result.cc
index 11d85ac..41a7d51 100644
--- a/boot/result.cc
+++ b/boot/result.cc
@@ -17,9 +17,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/result.h"
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     error::error(const char *path, const struct position position)
         : position(position), path(path)
@@ -46,4 +44,3 @@ namespace boot
         return m_errors;
     }
 }
-}
diff --git a/boot/semantic.cc b/boot/semantic.cc
index 408082a..7211103 100644
--- a/boot/semantic.cc
+++ b/boot/semantic.cc
@@ -17,9 +17,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/semantic.h"
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     undeclared_error::undeclared_error(const std::string& identifier, const char *path, const struct position position)
         : error(path, position), identifier(identifier)
@@ -121,5 +119,129 @@ namespace boot
     void declaration_visitor::visit(procedure_type_expression *)
     {
     }
-}
+
+    void declaration_visitor::visit(variable_declaration *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(constant_definition *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(procedure_definition *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(assign_statement *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(if_statement *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(while_statement *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(return_statement *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(defer_statement *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(procedure_call *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(block *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(traits_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(cast_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(binary_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(unary_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(variable_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(array_access_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(field_access_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(dereference_expression *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(literal<std::int32_t> *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(literal<std::uint32_t> *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(literal<double> *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(literal<bool> *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(literal<unsigned char> *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(literal<std::nullptr_t> *)
+    {
+        __builtin_unreachable();
+    }
+
+    void declaration_visitor::visit(literal<std::string> *)
+    {
+        __builtin_unreachable();
+    }
 }
diff --git a/boot/symbol.cc b/boot/symbol.cc
index c3ba0f2..0e2de25 100644
--- a/boot/symbol.cc
+++ b/boot/symbol.cc
@@ -17,9 +17,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/symbol.h"
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     type::type()
     {
@@ -301,4 +299,3 @@ namespace boot
         return result;
     }
 }
-}
diff --git a/gcc/elna-builtins.cc b/gcc/elna-builtins.cc
index 262d567..576b61b 100644
--- a/gcc/elna-builtins.cc
+++ b/gcc/elna-builtins.cc
@@ -21,9 +21,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "stringpool.h"
 #include "elna/gcc/elna-tree.h"
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     void init_ttree()
     {
@@ -66,4 +64,3 @@ namespace gcc
         return symbol_table;
     }
 }
-}
diff --git a/gcc/elna-diagnostic.cc b/gcc/elna-diagnostic.cc
index b988f61..3668048 100644
--- a/gcc/elna-diagnostic.cc
+++ b/gcc/elna-diagnostic.cc
@@ -19,9 +19,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/gcc/elna-tree.h"
 #include "elna/gcc/elna1.h"
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     location_t get_location(const boot::position *position)
     {
@@ -144,4 +142,3 @@ namespace gcc
         }
     }
 }
-}
diff --git a/gcc/elna-generic.cc b/gcc/elna-generic.cc
index 0d4926d..084a1fb 100644
--- a/gcc/elna-generic.cc
+++ b/gcc/elna-generic.cc
@@ -34,9 +34,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "fold-const.h"
 #include "langhooks.h"
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     tree get_inner_alias(const boot::type& type, std::shared_ptr<symbol_table> symbols)
     {
@@ -317,7 +315,7 @@ namespace gcc
         tree fndecl = build_fn_decl(definition->identifier.c_str(), declaration_type);
         this->symbols->enter(definition->identifier, fndecl);
 
-        if (definition->heading().no_return)
+        if (definition->heading().return_type.no_return)
         {
             TREE_THIS_VOLATILE(fndecl) = 1;
         }
@@ -336,19 +334,22 @@ namespace gcc
         function_args_iterator parameter_type;
         function_args_iter_init(&parameter_type, declaration_type);
 
-        for (const boot::variable_declaration *parameter : definition->heading().parameters)
+        std::vector<std::string>::const_iterator parameter_name = definition->parameter_names.cbegin();
+
+        for (std::shared_ptr<boot::type_expression> parameter : definition->heading().parameters)
         {
             tree declaration_tree = build_decl(get_location(&parameter->position()), PARM_DECL,
-                get_identifier(parameter->identifier.c_str()), function_args_iter_cond(&parameter_type));
+                get_identifier(parameter_name->c_str()), function_args_iter_cond(&parameter_type));
             DECL_CONTEXT(declaration_tree) = fndecl;
             DECL_ARG_TYPE(declaration_tree) = function_args_iter_cond(&parameter_type);
 
             if (definition->body != nullptr)
             {
-                this->symbols->enter(parameter->identifier, declaration_tree);
+                this->symbols->enter(*parameter_name, declaration_tree);
             }
             argument_chain = chainon(argument_chain, declaration_tree);
             function_args_iter_next(&parameter_type);
+            ++parameter_name;
         }
         DECL_ARGUMENTS(fndecl) = argument_chain;
         TREE_PUBLIC(fndecl) = definition->exported;
@@ -409,17 +410,17 @@ namespace gcc
         return bind_expr;
     }
 
-    void generic_visitor::visit(boot::number_literal<std::int32_t> *literal)
+    void generic_visitor::visit(boot::literal<std::int32_t> *literal)
     {
         this->current_expression = build_int_cst(elna_int_type_node, literal->value);
     }
 
-    void generic_visitor::visit(boot::number_literal<std::uint32_t> *literal)
+    void generic_visitor::visit(boot::literal<std::uint32_t> *literal)
     {
         this->current_expression = build_int_cstu(elna_word_type_node, literal->value);
     }
 
-    void generic_visitor::visit(boot::number_literal<double> *literal)
+    void generic_visitor::visit(boot::literal<double> *literal)
     {
         REAL_VALUE_TYPE real_value1;
 
@@ -434,22 +435,22 @@ namespace gcc
         mpfr_clear(number);
     }
 
-    void generic_visitor::visit(boot::number_literal<bool> *boolean)
+    void generic_visitor::visit(boot::literal<bool> *boolean)
     {
         this->current_expression = boolean->value ? boolean_true_node : boolean_false_node;
     }
 
-    void generic_visitor::visit(boot::number_literal<unsigned char> *character)
+    void generic_visitor::visit(boot::literal<unsigned char> *character)
     {
         this->current_expression = build_int_cstu(elna_char_type_node, character->value);
     }
 
-    void generic_visitor::visit(boot::number_literal<nullptr_t> *)
+    void generic_visitor::visit(boot::literal<nullptr_t> *)
     {
         this->current_expression = elna_pointer_nil_node;
     }
 
-    void generic_visitor::visit(boot::number_literal<std::string> *string)
+    void generic_visitor::visit(boot::literal<std::string> *string)
     {
         tree index_constant = build_int_cstu(elna_word_type_node, string->value.size());
         tree string_type = build_array_type(elna_char_type_node, build_index_type(index_constant));
@@ -779,15 +780,14 @@ namespace gcc
 
         for (std::size_t i = 0; i < type.parameters.size(); ++i)
         {
-            boot::type_expression& parameter_type = type.parameters.at(i)->variable_type();
-            parameter_type.accept(this);
+            type.parameters.at(i)->accept(this);
             parameter_types[i] = this->current_expression;
         }
         tree return_type = void_type_node;
 
-        if (type.return_type != nullptr)
+        if (type.return_type.type != nullptr)
         {
-            type.return_type->accept(this);
+            type.return_type.type->accept(this);
             return_type = this->current_expression;
         }
         this->current_expression = NULL_TREE;
@@ -924,32 +924,105 @@ namespace gcc
         }
     }
 
+    bool generic_visitor::expect_trait_type_only(boot::traits_expression *trait)
+    {
+        if (trait->parameters.size() != 1)
+        {
+            error_at(get_location(&trait->position()), "Trait '%s' expects 1 argument, got %lu",
+                    trait->name.c_str(), trait->parameters.size());
+            this->current_expression = error_mark_node;
+            return false;
+        }
+        trait->parameters.front()->accept(this);
+
+        return this->current_expression != error_mark_node;
+    }
+
+    bool generic_visitor::expect_trait_for_integral_type(boot::traits_expression *trait)
+    {
+        if (!expect_trait_type_only(trait))
+        {
+            return false;
+        }
+        else if (!is_integral_type(this->current_expression))
+        {
+            error_at(get_location(&trait->position()), "Type '%s' does not support trait '%s'",
+                    print_type(this->current_expression).c_str(), trait->name.c_str());
+            this->current_expression = error_mark_node;
+            return false;
+        }
+        return true;
+    }
+
     void generic_visitor::visit(boot::traits_expression *trait)
     {
-        trait->type().accept(this);
+        location_t trait_location = get_location(&trait->position());
 
         if (trait->name == "size")
         {
-            this->current_expression = build1(CONVERT_EXPR, elna_word_type_node,
-                    size_in_bytes(this->current_expression));
+            if (expect_trait_type_only(trait))
+            {
+                this->current_expression = build1_loc(trait_location, CONVERT_EXPR, elna_word_type_node,
+                        size_in_bytes(this->current_expression));
+            }
         }
         else if (trait->name == "alignment")
         {
-            this->current_expression = build_int_cstu(elna_word_type_node,
-                    TYPE_ALIGN_UNIT(this->current_expression));
+            if (expect_trait_type_only(trait))
+            {
+                this->current_expression = build_int_cstu(elna_word_type_node,
+                        TYPE_ALIGN_UNIT(this->current_expression));
+            }
         }
-        else if (trait->name == "min" && is_integral_type(this->current_expression))
+        else if (trait->name == "min")
         {
-            this->current_expression = TYPE_MIN_VALUE(this->current_expression);
+            if (expect_trait_for_integral_type(trait))
+            {
+                this->current_expression = TYPE_MIN_VALUE(this->current_expression);
+            }
         }
-        else if (trait->name == "max" && is_integral_type(this->current_expression))
+        else if (trait->name == "max")
         {
-            this->current_expression = TYPE_MAX_VALUE(this->current_expression);
+            if (expect_trait_for_integral_type(trait))
+            {
+                this->current_expression = TYPE_MAX_VALUE(this->current_expression);
+            }
+        }
+        else if (trait->name == "offset")
+        {
+            if (trait->parameters.size() != 2)
+            {
+                error_at(trait_location, "Trait '%s' expects 2 arguments, got %lu",
+                        trait->name.c_str(), trait->parameters.size());
+                this->current_expression = error_mark_node;
+                return;
+            }
+            trait->parameters.front()->accept(this);
+            auto field_type = trait->parameters.at(1)->is_primitive();
+
+            if (field_type == nullptr)
+            {
+                error_at(trait_location,
+                        "The second argument to the offset trait is expected to be a field name,"
+                        "got a type expression");
+                this->current_expression = error_mark_node;
+                return;
+            }
+            tree field_declaration = find_field_by_name(trait_location, this->current_expression, field_type->name);
+
+            if (field_declaration != error_mark_node)
+            {
+                this->current_expression = build1(CONVERT_EXPR, elna_word_type_node,
+                        byte_position(field_declaration));
+            }
+            else
+            {
+                this->current_expression = error_mark_node;
+            }
         }
         else
         {
-            error_at(get_location(&trait->position()), "type '%s' does not have property '%s'",
-                    print_type(this->current_expression).c_str(), trait->name.c_str());
+            error_at(get_location(&trait->position()), "Trait '%s' is unknown", trait->name.c_str());
             this->current_expression = error_mark_node;
         }
     }
@@ -958,41 +1031,14 @@ namespace gcc
     {
         expression->base().accept(this);
         location_t expression_location = get_location(&expression->position());
+        tree field_declaration = find_field_by_name(expression_location,
+                TREE_TYPE(this->current_expression), expression->field());
 
-        if (is_aggregate_type(TREE_TYPE(this->current_expression)))
+        if (field_declaration != error_mark_node)
         {
-            tree field_declaration = TYPE_FIELDS(TREE_TYPE(this->current_expression));
-
-            while (field_declaration != NULL_TREE)
-            {
-                tree declaration_name = DECL_NAME(field_declaration);
-                const char *identifier_pointer = IDENTIFIER_POINTER(declaration_name);
-
-                if (expression->field() == identifier_pointer)
-                {
-                    break;
-                }
-                field_declaration = TREE_CHAIN(field_declaration);
-            }
-            if (field_declaration == NULL_TREE)
-            {
-                error_at(expression_location,
-                        "record type does not have a field named '%s'",
-                        expression->field().c_str());
-                this->current_expression = error_mark_node;
-            }
-            else
-            {
-                this->current_expression = build3_loc(expression_location, COMPONENT_REF,
-                        TREE_TYPE(field_declaration), this->current_expression,
-                        field_declaration, NULL_TREE);
-            }
-        }
-        else
-        {
-            error_at(expression_location, "type '%s' does not have a field named '%s'",
-                    print_type(TREE_TYPE(this->current_expression)).c_str(), expression->field().c_str());
-            this->current_expression = error_mark_node;
+            this->current_expression = build3_loc(expression_location, COMPONENT_REF,
+                    TREE_TYPE(field_declaration), this->current_expression,
+                    field_declaration, NULL_TREE);
         }
     }
 
@@ -1226,4 +1272,3 @@ namespace gcc
         defer(leave_scope());
     }
 }
-}
diff --git a/gcc/elna-tree.cc b/gcc/elna-tree.cc
index c8262df..b35e260 100644
--- a/gcc/elna-tree.cc
+++ b/gcc/elna-tree.cc
@@ -24,9 +24,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "fold-const.h"
 #include "diagnostic-core.h"
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     bool is_pointer_type(tree type)
     {
@@ -209,5 +207,37 @@ namespace gcc
             return error_mark_node;
         }
     }
-}
+
+    tree find_field_by_name(location_t expression_location, tree type, const std::string& field_name)
+    {
+        if (type == error_mark_node)
+        {
+            return type;
+        }
+        tree field_declaration = TYPE_FIELDS(type);
+
+        if (!is_aggregate_type(type))
+        {
+            error_at(expression_location, "type '%s' does not have a field named '%s'",
+                    print_type(type).c_str(), field_name.c_str());
+            return error_mark_node;
+        }
+        while (field_declaration != NULL_TREE)
+        {
+            tree declaration_name = DECL_NAME(field_declaration);
+            const char *identifier_pointer = IDENTIFIER_POINTER(declaration_name);
+
+            if (field_name == identifier_pointer)
+            {
+                break;
+            }
+            field_declaration = TREE_CHAIN(field_declaration);
+        }
+        if (field_declaration == NULL_TREE)
+        {
+            error_at(expression_location, "record type does not have a field named '%s'", field_name.c_str());
+            return error_mark_node;
+        }
+        return field_declaration;
+    }
 }
diff --git a/include/elna/boot/ast.h b/include/elna/boot/ast.h
index 6c32a54..9abfff4 100644
--- a/include/elna/boot/ast.h
+++ b/include/elna/boot/ast.h
@@ -21,11 +21,10 @@ along with GCC; see the file COPYING3.  If not see
 #include <memory>
 #include <string>
 #include <vector>
+#include <variant>
 #include "elna/boot/result.h"
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     enum class binary_operator
     {
@@ -80,9 +79,9 @@ namespace boot
     class field_access_expression;
     class dereference_expression;
     class designator_expression;
-    class literal;
+    class literal_expression;
     template<typename T>
-    class number_literal;
+    class literal;
     class defer_statement;
 
     /**
@@ -116,53 +115,13 @@ namespace boot
         virtual void visit(array_access_expression *) = 0;
         virtual void visit(field_access_expression *) = 0;
         virtual void visit(dereference_expression *) = 0;
-        virtual void visit(number_literal<std::int32_t> *) = 0;
-        virtual void visit(number_literal<std::uint32_t> *) = 0;
-        virtual void visit(number_literal<double> *) = 0;
-        virtual void visit(number_literal<bool> *) = 0;
-        virtual void visit(number_literal<unsigned char> *) = 0;
-        virtual void visit(number_literal<std::nullptr_t> *) = 0;
-        virtual void visit(number_literal<std::string> *) = 0;
-    };
-
-    /**
-     * A visitor which visits all nodes but does nothing.
-     */
-    struct empty_visitor : parser_visitor
-    {
-        virtual void visit(variable_declaration *) override;
-        virtual void visit(constant_definition *) override;
-        virtual void visit(procedure_definition *) override;
-        virtual void visit(type_definition *) override;
-        virtual void visit(procedure_call *) override;
-        virtual void visit(cast_expression *) override;
-        virtual void visit(traits_expression *) override;
-        virtual void visit(assign_statement *) override;
-        virtual void visit(if_statement *) override;
-        virtual void visit(while_statement *) override;
-        virtual void visit(return_statement *) override;
-        virtual void visit(defer_statement *) override;
-        virtual void visit(block *) override;
-        virtual void visit(program *) override;
-        virtual void visit(binary_expression *) override;
-        virtual void visit(unary_expression *) override;
-        virtual void visit(primitive_type_expression *) override;
-        virtual void visit(array_type_expression *) override;
-        virtual void visit(pointer_type_expression *) override;
-        virtual void visit(record_type_expression *) override;
-        virtual void visit(union_type_expression *) override;
-        virtual void visit(procedure_type_expression *) override;
-        virtual void visit(variable_expression *) override;
-        virtual void visit(array_access_expression *) override;
-        virtual void visit(field_access_expression *) override;
-        virtual void visit(dereference_expression *) override;
-        virtual void visit(number_literal<std::int32_t> *) override;
-        virtual void visit(number_literal<std::uint32_t> *) override;
-        virtual void visit(number_literal<double> *) override;
-        virtual void visit(number_literal<bool> *) override;
-        virtual void visit(number_literal<unsigned char> *) override;
-        virtual void visit(number_literal<std::nullptr_t> *) override;
-        virtual void visit(number_literal<std::string> *) override;
+        virtual void visit(literal<std::int32_t> *) = 0;
+        virtual void visit(literal<std::uint32_t> *) = 0;
+        virtual void visit(literal<double> *) = 0;
+        virtual void visit(literal<bool> *) = 0;
+        virtual void visit(literal<unsigned char> *) = 0;
+        virtual void visit(literal<std::nullptr_t> *) = 0;
+        virtual void visit(literal<std::string> *) = 0;
     };
 
     /**
@@ -213,7 +172,7 @@ namespace boot
         virtual unary_expression *is_unary();
         virtual designator_expression *is_designator();
         virtual procedure_call *is_call_expression();
-        virtual literal *is_literal();
+        virtual literal_expression *is_literal();
 
         void accept(parser_visitor *visitor);
         ~expression() = 0;
@@ -336,22 +295,22 @@ namespace boot
     /**
      * Literal expression.
      */
-    class literal : public expression
+    class literal_expression : public expression
     {
     public:
-        virtual number_literal<std::int32_t> *is_int() = 0;
-        virtual number_literal<std::uint32_t> *is_word() = 0;
-        virtual number_literal<double> *is_float() = 0;
-        virtual number_literal<bool> *is_bool() = 0;
-        virtual number_literal<unsigned char> *is_char() = 0;
-        virtual number_literal<std::nullptr_t> *is_nil() = 0;
-        virtual number_literal<std::string> *is_string() = 0;
+        virtual literal<std::int32_t> *is_int() = 0;
+        virtual literal<std::uint32_t> *is_word() = 0;
+        virtual literal<double> *is_float() = 0;
+        virtual literal<bool> *is_bool() = 0;
+        virtual literal<unsigned char> *is_char() = 0;
+        virtual literal<std::nullptr_t> *is_nil() = 0;
+        virtual literal<std::string> *is_string() = 0;
 
-        literal *is_literal() override;
+        literal_expression *is_literal() override;
         void accept(parser_visitor *visitor);
 
     protected:
-        literal();
+        literal_expression();
     };
 
     /**
@@ -359,7 +318,7 @@ namespace boot
      */
     class constant_definition : public definition
     {
-        literal *m_body;
+        literal_expression *m_body;
 
     public:
         /**
@@ -368,10 +327,10 @@ namespace boot
          * \param body Constant value.
          */
         constant_definition(const struct position position, const std::string& identifier,
-                const bool exported, literal *body);
+                const bool exported, literal_expression *body);
         void accept(parser_visitor *visitor);
 
-        literal& body();
+        literal_expression& body();
 
         virtual ~constant_definition() override;
     };
@@ -379,10 +338,15 @@ namespace boot
     /**
      * Tags a procedure type as never returning.
      */
-    struct no_return_t
+    struct return_declaration
     {
+        return_declaration() = default;
+        explicit return_declaration(std::shared_ptr<type_expression> type);
+        explicit return_declaration(std::monostate);
+
+        std::shared_ptr<type_expression> type{ nullptr };
+        bool no_return{ false };
     };
-    constexpr no_return_t no_return{};
 
     /**
      * Procedure type.
@@ -390,18 +354,14 @@ namespace boot
     class procedure_type_expression : public type_expression
     {
     public:
-        const std::shared_ptr<type_expression> return_type;
-        const bool no_return;
-        std::vector<variable_declaration *> parameters;
+        const return_declaration return_type;
+        std::vector<std::shared_ptr<type_expression>> parameters;
 
         procedure_type_expression(const struct position position,
-                std::shared_ptr<type_expression> return_type = nullptr);
-        procedure_type_expression(const struct position position, no_return_t);
+                return_declaration return_type = return_declaration());
 
         void accept(parser_visitor *visitor);
         std::shared_ptr<procedure_type_expression> is_procedure() override;
-
-        virtual ~procedure_type_expression() override;
     };
 
     /**
@@ -413,6 +373,7 @@ namespace boot
 
     public:
         block *const body;
+        std::vector<std::string> parameter_names;
 
         procedure_definition(const struct position position, const std::string& identifier,
                 const bool exported, std::shared_ptr<procedure_type_expression> heading, block *body = nullptr);
@@ -459,17 +420,13 @@ namespace boot
 
     class traits_expression : public expression
     {
-        std::shared_ptr<type_expression> m_type;
-
     public:
+        std::vector<std::shared_ptr<type_expression>> parameters;
         const std::string name;
 
-        traits_expression(const struct position position, const std::string& name,
-                std::shared_ptr<type_expression> type);
+        traits_expression(const struct position position, const std::string& name);
         void accept(parser_visitor *visitor);
         traits_expression *is_traits() override;
-
-        type_expression& type();
     };
 
     /**
@@ -688,21 +645,21 @@ namespace boot
     };
 
     template<typename T>
-    class number_literal : public literal
+    class literal : public literal_expression
     {
     public:
         T value;
 
-        number_literal(const struct position position, const T& value)
+        literal(const struct position position, const T& value)
             : node(position), value(value)
         {
         }
 
-        number_literal<std::int32_t> *is_int() override
+        literal<std::int32_t> *is_int() override
         {
             if (std::is_same<T, std::int32_t>::value)
             {
-                return reinterpret_cast<number_literal<std::int32_t> *>(this);
+                return reinterpret_cast<literal<std::int32_t> *>(this);
             }
             else
             {
@@ -710,11 +667,11 @@ namespace boot
             }
         }
 
-        number_literal<std::uint32_t> *is_word() override
+        literal<std::uint32_t> *is_word() override
         {
             if (std::is_same<T, std::uint32_t>::value)
             {
-                return reinterpret_cast<number_literal<std::uint32_t> *>(this);
+                return reinterpret_cast<literal<std::uint32_t> *>(this);
             }
             else
             {
@@ -722,11 +679,11 @@ namespace boot
             }
         }
 
-        number_literal<double> *is_float() override
+        literal<double> *is_float() override
         {
             if (std::is_same<T, double>::value)
             {
-                return reinterpret_cast<number_literal<double> *>(this);
+                return reinterpret_cast<literal<double> *>(this);
             }
             else
             {
@@ -734,11 +691,11 @@ namespace boot
             }
         }
 
-        number_literal<bool> *is_bool() override
+        literal<bool> *is_bool() override
         {
             if (std::is_same<T, bool>::value)
             {
-                return reinterpret_cast<number_literal<bool> *>(this);
+                return reinterpret_cast<literal<bool> *>(this);
             }
             else
             {
@@ -746,11 +703,11 @@ namespace boot
             }
         }
 
-        number_literal<unsigned char> *is_char() override
+        literal<unsigned char> *is_char() override
         {
             if (std::is_same<T, unsigned char>::value)
             {
-                return reinterpret_cast<number_literal<unsigned char> *>(this);
+                return reinterpret_cast<literal<unsigned char> *>(this);
             }
             else
             {
@@ -758,11 +715,11 @@ namespace boot
             }
         }
 
-        number_literal<std::nullptr_t> *is_nil() override
+        literal<std::nullptr_t> *is_nil() override
         {
             if (std::is_same<T, std::nullptr_t>::value)
             {
-                return reinterpret_cast<number_literal<std::nullptr_t> *>(this);
+                return reinterpret_cast<literal<std::nullptr_t> *>(this);
             }
             else
             {
@@ -770,11 +727,11 @@ namespace boot
             }
         }
 
-        number_literal<std::string> *is_string() override
+        literal<std::string> *is_string() override
         {
             if (std::is_same<T, std::string>::value)
             {
-                return reinterpret_cast<number_literal<std::string> *>(this);
+                return reinterpret_cast<literal<std::string> *>(this);
             }
             else
             {
@@ -840,4 +797,3 @@ namespace boot
 
     const char *print_binary_operator(const binary_operator operation);
 }
-}
diff --git a/include/elna/boot/driver.h b/include/elna/boot/driver.h
index f09da87..0f3a37f 100644
--- a/include/elna/boot/driver.h
+++ b/include/elna/boot/driver.h
@@ -21,9 +21,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/boot/ast.h"
 #include "location.hh"
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     position make_position(const yy::location& location);
 
@@ -50,4 +48,3 @@ namespace boot
 
     char escape_char(char escape);
 }
-}
diff --git a/include/elna/boot/result.h b/include/elna/boot/result.h
index 65bfe59..f053ece 100644
--- a/include/elna/boot/result.h
+++ b/include/elna/boot/result.h
@@ -22,9 +22,7 @@ along with GCC; see the file COPYING3.  If not see
 #include <deque>
 #include <memory>
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     /**
      * Position in the source text.
@@ -82,4 +80,3 @@ namespace boot
         }
     };
 }
-}
diff --git a/include/elna/boot/semantic.h b/include/elna/boot/semantic.h
index 5517026..a682325 100644
--- a/include/elna/boot/semantic.h
+++ b/include/elna/boot/semantic.h
@@ -24,9 +24,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/boot/result.h"
 #include "elna/boot/symbol.h"
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     class undeclared_error : public error
     {
@@ -48,7 +46,7 @@ namespace boot
         std::string what() const override;
     };
 
-    class declaration_visitor final : public empty_visitor, public error_container
+    class declaration_visitor final : public parser_visitor, public error_container
     {
         type current_type;
         std::shared_ptr<symbol_table> symbols;
@@ -66,6 +64,31 @@ namespace boot
         void visit(record_type_expression *) override;
         void visit(union_type_expression *) override;
         void visit(procedure_type_expression *) override;
+
+        void visit(variable_declaration *) override;
+        void visit(constant_definition *) override;
+        void visit(procedure_definition *) override;
+        void visit(assign_statement *) override;
+        void visit(if_statement *) override;
+        void visit(while_statement *) override;
+        void visit(return_statement *) override;
+        void visit(defer_statement *) override;
+        void visit(procedure_call *) override;
+        void visit(block *) override;
+        void visit(cast_expression *) override;
+        void visit(traits_expression *) override;
+        void visit(binary_expression *) override;
+        void visit(unary_expression *) override;
+        void visit(variable_expression *) override;
+        void visit(array_access_expression *) override;
+        void visit(field_access_expression *) override;
+        void visit(dereference_expression *) override;
+        void visit(literal<std::int32_t> *) override;
+        void visit(literal<std::uint32_t> *) override;
+        void visit(literal<double> *) override;
+        void visit(literal<bool> *) override;
+        void visit(literal<unsigned char> *) override;
+        void visit(literal<std::nullptr_t> *) override;
+        void visit(literal<std::string> *) override;
     };
 }
-}
diff --git a/include/elna/boot/symbol.h b/include/elna/boot/symbol.h
index ac783ab..1d6a779 100644
--- a/include/elna/boot/symbol.h
+++ b/include/elna/boot/symbol.h
@@ -23,9 +23,7 @@ along with GCC; see the file COPYING3.  If not see
 #include <memory>
 #include <vector>
 
-namespace elna
-{
-namespace boot
+namespace elna::boot
 {
     class alias_type;
     class primitive_type;
@@ -257,4 +255,3 @@ namespace boot
 
     std::shared_ptr<symbol_table> builtin_symbol_table();
 }
-}
diff --git a/include/elna/gcc/elna-builtins.h b/include/elna/gcc/elna-builtins.h
index ed5b749..251b894 100644
--- a/include/elna/gcc/elna-builtins.h
+++ b/include/elna/gcc/elna-builtins.h
@@ -25,11 +25,8 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/gcc/elna-tree.h"
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     void init_ttree();
     std::shared_ptr<symbol_table> builtin_symbol_table();
 }
-}
diff --git a/include/elna/gcc/elna-diagnostic.h b/include/elna/gcc/elna-diagnostic.h
index d225505..2f37ee9 100644
--- a/include/elna/gcc/elna-diagnostic.h
+++ b/include/elna/gcc/elna-diagnostic.h
@@ -29,12 +29,9 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "elna/boot/result.h"
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     location_t get_location(const boot::position *position);
     std::string print_type(tree type);
     void report_errors(const std::deque<std::unique_ptr<boot::error>>& errors);
 }
-}
diff --git a/include/elna/gcc/elna-generic.h b/include/elna/gcc/elna-generic.h
index 5ae5f90..1a85f68 100644
--- a/include/elna/gcc/elna-generic.h
+++ b/include/elna/gcc/elna-generic.h
@@ -30,16 +30,14 @@ along with GCC; see the file COPYING3.  If not see
 
 #include <string>
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     std::deque<std::unique_ptr<boot::error>> do_semantic_analysis(const char *path,
             std::unique_ptr<boot::program>& ast, std::shared_ptr<boot::symbol_table> info_table,
             std::shared_ptr<symbol_table> symbols);
     tree handle_symbol(const std::string& symbol_name, const boot::type& type, std::shared_ptr<symbol_table> symbols);
 
-    class generic_visitor final : public boot::empty_visitor
+    class generic_visitor final : public boot::parser_visitor
     {
         tree current_expression{ NULL_TREE };
         std::shared_ptr<symbol_table> symbols;
@@ -64,6 +62,9 @@ namespace gcc
                 tree procedure_address, const std::vector<boot::expression *>& arguments);
         void build_record_call(location_t call_location,
                 tree symbol, const std::vector<boot::expression *>& arguments);
+
+        bool expect_trait_type_only(boot::traits_expression *trait);
+        bool expect_trait_for_integral_type(boot::traits_expression *trait);
         void visit_statements(const std::vector<boot::statement *>& statements);
 
     public:
@@ -74,13 +75,13 @@ namespace gcc
         void visit(boot::procedure_call *call) override;
         void visit(boot::cast_expression *expression) override;
         void visit(boot::traits_expression *trait) override;
-        void visit(boot::number_literal<std::int32_t> *literal) override;
-        void visit(boot::number_literal<std::uint32_t> *literal) override;
-        void visit(boot::number_literal<double> *literal) override;
-        void visit(boot::number_literal<bool> *boolean) override;
-        void visit(boot::number_literal<unsigned char> *character) override;
-        void visit(boot::number_literal<std::nullptr_t> *) override;
-        void visit(boot::number_literal<std::string> *string) override;
+        void visit(boot::literal<std::int32_t> *literal) override;
+        void visit(boot::literal<std::uint32_t> *literal) override;
+        void visit(boot::literal<double> *literal) override;
+        void visit(boot::literal<bool> *boolean) override;
+        void visit(boot::literal<unsigned char> *character) override;
+        void visit(boot::literal<std::nullptr_t> *) override;
+        void visit(boot::literal<std::string> *string) override;
         void visit(boot::binary_expression *expression) override;
         void visit(boot::unary_expression *expression) override;
         void visit(boot::constant_definition *definition) override;
@@ -104,4 +105,3 @@ namespace gcc
         void visit(boot::defer_statement *statement) override;
     };
 }
-}
diff --git a/include/elna/gcc/elna-tree.h b/include/elna/gcc/elna-tree.h
index 636a817..027cdba 100644
--- a/include/elna/gcc/elna-tree.h
+++ b/include/elna/gcc/elna-tree.h
@@ -29,9 +29,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "elna/boot/ast.h"
 #include "elna/boot/symbol.h"
 
-namespace elna
-{
-namespace gcc
+namespace elna::gcc
 {
     using symbol_table = boot::symbol_map<tree, tree, NULL_TREE>;
 
@@ -81,5 +79,5 @@ namespace gcc
     tree build_arithmetic_operation(boot::binary_expression *expression,
             tree_code operator_code, tree left, tree right);
     tree build_field(location_t location, tree record_type, const std::string name, tree type);
-}
+    tree find_field_by_name(location_t expression_location, tree type, const std::string& field_name);
 }
diff --git a/source.elna b/source.elna
index f6e3400..99770f2 100644
--- a/source.elna
+++ b/source.elna
@@ -88,9 +88,9 @@ type
     position: Position
 
 	input: ^Byte
-	empty: proc(data: ^Byte) -> Bool
-	advance: proc(data: ^Byte)
-	head: proc(data: ^Byte) -> Char
+	empty: proc(^Byte) -> Bool
+	advance: proc(^Byte)
+	head: proc(^Byte) -> Char
   end
   Token* = record
     kind: Int