From 51f58714eb8fb72252c7622c7069009e4648d213 Mon Sep 17 00:00:00 2001
From: Harry Denholm <harry.denholm@gmail.com>
Date: Wed, 22 Oct 2025 17:16:23 +0100
Subject: [PATCH 1/2] Move the construction of the OOB violation string to
 after the OOB check fails so that the code is not allocating, concatenating
 and freeing strings that are never used in regular operation - this can
 produce a severe performance penalty

---
 include/cpp2util.h | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/include/cpp2util.h b/include/cpp2util.h
index 57ed3c651..06206def2 100644
--- a/include/cpp2util.h
+++ b/include/cpp2util.h
@@ -1224,14 +1224,14 @@ constexpr auto assert_not_zero(auto&& arg CPP2_SOURCE_LOCATION_PARAM_WITH_DEFAUL
         if constexpr (std::is_signed_v<CPP2_TYPEOF(arg)>) { return std::ssize(x); } \
         else { return std::size(x); } \
     }; \
-    auto msg = "out of bounds access attempt detected - attempted access at index " + std::to_string(arg) + ", "; \
-    if (max() > 0 ) { \
-        msg += "[min,max] range is [0," + std::to_string(max()-1) + "]"; \
-    } \
-    else { \
-        msg += "but container is empty"; \
-    } \
     if (!(0 <= arg && arg < max())) { \
+        auto msg = "out of bounds access attempt detected - attempted access at index " + std::to_string(arg) + ", "; \
+        if (max() > 0 ) { \
+            msg += "[min,max] range is [0," + std::to_string(max()-1) + "]"; \
+        } \
+        else { \
+            msg += "but container is empty"; \
+        } \
         bounds_safety.report_violation(msg.c_str()  CPP2_SOURCE_LOCATION_ARG); \
     } \
     return CPP2_FORWARD(x) [ arg ]; \

From ccfad71de174760d112c65983c6e5e3a2a6a42e1 Mon Sep 17 00:00:00 2001
From: Harry Denholm <harry.denholm@gmail.com>
Date: Wed, 22 Oct 2025 17:43:47 +0100
Subject: [PATCH 2/2] euclidean_vector metafunction experiment, used to garnish
 classic geometry vector types with myriad convenience operators; eg. adding
 vectors, multiplying by single values, getting length, normalising

---
 source/reflect.h  | 2143 ++++++++++++++++++++++++---------------------
 source/reflect.h2 |  175 ++++
 2 files changed, 1336 insertions(+), 982 deletions(-)

diff --git a/source/reflect.h b/source/reflect.h
index c80c4977c..456ed910c 100644
--- a/source/reflect.h
+++ b/source/reflect.h
@@ -102,118 +102,118 @@ class return_statement;
 #line 1479 "reflect.h2"
 class iteration_statement;
 
-#line 1976 "reflect.h2"
+#line 2148 "reflect.h2"
 class value_member_info;
 
-#line 2619 "reflect.h2"
+#line 2791 "reflect.h2"
 class simple_traverser;
 
-#line 4111 "reflect.h2"
+#line 4283 "reflect.h2"
 class autodiff_special_func;
 
-#line 4155 "reflect.h2"
+#line 4327 "reflect.h2"
 class autodiff_declared_variable;
 
-#line 4173 "reflect.h2"
+#line 4345 "reflect.h2"
 class autodiff_declaration_stack_item;
 
-#line 4217 "reflect.h2"
+#line 4389 "reflect.h2"
 class autodiff_context;
     
 
-#line 4613 "reflect.h2"
+#line 4785 "reflect.h2"
 class autodiff_diff_code;
     
 
-#line 4662 "reflect.h2"
+#line 4834 "reflect.h2"
 class autodiff_activity_check;
     
 
-#line 4760 "reflect.h2"
+#line 4932 "reflect.h2"
 class autodiff_handler_base;
     
 
-#line 4778 "reflect.h2"
+#line 4950 "reflect.h2"
 class autodiff_expression_handler;
     
 
-#line 5421 "reflect.h2"
+#line 5593 "reflect.h2"
 class autodiff_stmt_handler;
 
-#line 5891 "reflect.h2"
+#line 6063 "reflect.h2"
 class autodiff_declaration_handler;
 
-#line 6243 "reflect.h2"
+#line 6415 "reflect.h2"
 class expression_flags;
 
-#line 6259 "reflect.h2"
+#line 6431 "reflect.h2"
 class regex_token;
 
-#line 6286 "reflect.h2"
+#line 6458 "reflect.h2"
 class regex_token_check;
 
-#line 6307 "reflect.h2"
+#line 6479 "reflect.h2"
 class regex_token_code;
 
-#line 6328 "reflect.h2"
+#line 6500 "reflect.h2"
 class regex_token_empty;
 
-#line 6346 "reflect.h2"
+#line 6518 "reflect.h2"
 class regex_token_list;
 
-#line 6398 "reflect.h2"
+#line 6570 "reflect.h2"
 class parse_context_group_state;
 
-#line 6459 "reflect.h2"
+#line 6631 "reflect.h2"
 class parse_context_branch_reset_state;
 
-#line 6502 "reflect.h2"
+#line 6674 "reflect.h2"
 class parse_context;
 
-#line 6903 "reflect.h2"
+#line 7075 "reflect.h2"
 class generation_function_context;
     
 
-#line 6921 "reflect.h2"
+#line 7093 "reflect.h2"
 class generation_context;
 
-#line 7120 "reflect.h2"
+#line 7292 "reflect.h2"
 class alternative_token;
 
-#line 7135 "reflect.h2"
+#line 7307 "reflect.h2"
 class alternative_token_gen;
 
-#line 7200 "reflect.h2"
+#line 7372 "reflect.h2"
 class any_token;
 
-#line 7217 "reflect.h2"
+#line 7389 "reflect.h2"
 class atomic_group_token;
 
-#line 7247 "reflect.h2"
+#line 7419 "reflect.h2"
 class char_token;
 
-#line 7362 "reflect.h2"
+#line 7534 "reflect.h2"
 class class_token;
 
-#line 7586 "reflect.h2"
+#line 7758 "reflect.h2"
 class group_ref_token;
 
-#line 7723 "reflect.h2"
+#line 7895 "reflect.h2"
 class group_token;
 
-#line 8070 "reflect.h2"
+#line 8242 "reflect.h2"
 class lookahead_lookbehind_token;
 
-#line 8165 "reflect.h2"
+#line 8337 "reflect.h2"
 class range_token;
 
-#line 8322 "reflect.h2"
+#line 8494 "reflect.h2"
 class special_range_token;
 
-#line 8408 "reflect.h2"
+#line 8580 "reflect.h2"
 template<typename Error_out> class regex_generator;
 
-#line 8671 "reflect.h2"
+#line 8846 "reflect.h2"
 }
 
 }
@@ -1346,32 +1346,35 @@ auto copy_constructible(meta::type_declaration& t) -> void;
 #line 1763 "reflect.h2"
 auto hashable(meta::type_declaration& t) -> void;
 
-#line 1796 "reflect.h2"
+#line 1799 "reflect.h2"
+auto euclidean_vector(meta::type_declaration& t) -> void;
+
+#line 1968 "reflect.h2"
 auto basic_value(meta::type_declaration& t) -> void;
 
-#line 1824 "reflect.h2"
+#line 1996 "reflect.h2"
 auto value(meta::type_declaration& t) -> void;
 
-#line 1830 "reflect.h2"
+#line 2002 "reflect.h2"
 auto weakly_ordered_value(meta::type_declaration& t) -> void;
 
-#line 1836 "reflect.h2"
+#line 2008 "reflect.h2"
 auto partially_ordered_value(meta::type_declaration& t) -> void;
 
-#line 1865 "reflect.h2"
+#line 2037 "reflect.h2"
 auto cpp1_rule_of_zero(meta::type_declaration& t) -> void;
 
-#line 1907 "reflect.h2"
+#line 2079 "reflect.h2"
 auto cpp2_struct(meta::type_declaration& t) -> void;
 
-#line 1976 "reflect.h2"
+#line 2148 "reflect.h2"
 class value_member_info {
     public: std::string name; 
     public: std::string type; 
     public: std::string value; 
     public: value_member_info(auto const& name_, auto const& type_, auto const& value_);
 
-#line 1980 "reflect.h2"
+#line 2152 "reflect.h2"
 };
 
 auto basic_enum(
@@ -1380,313 +1383,313 @@ auto basic_enum(
     cpp2::impl::in<bool> bitwise
     ) -> void;
 
-#line 2246 "reflect.h2"
+#line 2418 "reflect.h2"
 auto cpp2_enum(meta::type_declaration& t) -> void;
 
-#line 2273 "reflect.h2"
+#line 2445 "reflect.h2"
 auto flag_enum(meta::type_declaration& t) -> void;
 
-#line 2319 "reflect.h2"
+#line 2491 "reflect.h2"
 auto cpp2_union(meta::type_declaration& t) -> void;
 
-#line 2470 "reflect.h2"
+#line 2642 "reflect.h2"
 auto print(cpp2::impl::in<meta::type_declaration> t) -> void;
 
-#line 2481 "reflect.h2"
+#line 2653 "reflect.h2"
 auto noisy(cpp2::impl::in<meta::type_declaration> t) -> void;
 struct python_param_names_and_types_ret { std::string names; std::string types; };
 
 
 
-#line 2505 "reflect.h2"
+#line 2677 "reflect.h2"
 [[nodiscard]] auto python_param_names_and_types(cpp2::impl::in<meta::function_declaration> mf) -> python_param_names_and_types_ret;
 
-#line 2527 "reflect.h2"
+#line 2699 "reflect.h2"
 auto python(meta::type_declaration& t) -> void;
 
-#line 2570 "reflect.h2"
+#line 2742 "reflect.h2"
 auto javascript(meta::type_declaration& t) -> void;
 
-#line 2611 "reflect.h2"
+#line 2783 "reflect.h2"
 auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 2619 "reflect.h2"
+#line 2791 "reflect.h2"
 class simple_traverser {
 
     public: virtual auto pre_traverse(cpp2::impl::in<meta::declaration> decl) -> void;
 
-#line 2625 "reflect.h2"
+#line 2797 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::declaration> decl) -> void;
 
-#line 2645 "reflect.h2"
+#line 2817 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::function_declaration> f) -> void;
 
-#line 2649 "reflect.h2"
+#line 2821 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::function_declaration> f) -> void;
 
-#line 2670 "reflect.h2"
+#line 2842 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::object_declaration> o) -> void;
 
-#line 2674 "reflect.h2"
+#line 2846 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::object_declaration> o) -> void;
 
-#line 2682 "reflect.h2"
+#line 2854 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::type_declaration> t) -> void;
 
-#line 2686 "reflect.h2"
+#line 2858 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::type_declaration> t) -> void;
 
-#line 2694 "reflect.h2"
+#line 2866 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void;
 
-#line 2698 "reflect.h2"
+#line 2870 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void;
 
-#line 2703 "reflect.h2"
+#line 2875 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::statement> stmt) -> void;
 
-#line 2707 "reflect.h2"
+#line 2879 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::statement> stmt) -> void;
 
-#line 2742 "reflect.h2"
+#line 2914 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::compound_statement> stmt) -> void;
 
-#line 2746 "reflect.h2"
+#line 2918 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::compound_statement> stmt) -> void;
 
-#line 2756 "reflect.h2"
+#line 2928 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::return_statement> stmt) -> void;
 
-#line 2760 "reflect.h2"
+#line 2932 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::return_statement> stmt) -> void;
 
-#line 2768 "reflect.h2"
+#line 2940 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::iteration_statement> stmt) -> void;
 
-#line 2772 "reflect.h2"
+#line 2944 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::iteration_statement> stmt) -> void;
 
-#line 2791 "reflect.h2"
+#line 2963 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::selection_statement> stmt) -> void;
 
-#line 2795 "reflect.h2"
+#line 2967 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::selection_statement> stmt) -> void;
 
-#line 2806 "reflect.h2"
+#line 2978 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::expression> expr) -> void;
 
-#line 2812 "reflect.h2"
+#line 2984 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::expression> expr) -> void;
 
-#line 2826 "reflect.h2"
+#line 2998 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void;
 
-#line 2843 "reflect.h2"
+#line 3015 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void;
 
-#line 2854 "reflect.h2"
+#line 3026 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void;
 
-#line 2871 "reflect.h2"
+#line 3043 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void;
 
-#line 2883 "reflect.h2"
+#line 3055 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void;
 
-#line 2900 "reflect.h2"
+#line 3072 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void;
 
-#line 2911 "reflect.h2"
+#line 3083 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void;
 
-#line 2928 "reflect.h2"
+#line 3100 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void;
 
-#line 2939 "reflect.h2"
+#line 3111 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void;
 
-#line 2956 "reflect.h2"
+#line 3128 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void;
 
-#line 2968 "reflect.h2"
+#line 3140 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void;
 
-#line 2985 "reflect.h2"
+#line 3157 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void;
 
-#line 2997 "reflect.h2"
+#line 3169 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void;
 
-#line 3014 "reflect.h2"
+#line 3186 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void;
 
-#line 3025 "reflect.h2"
+#line 3197 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void;
 
-#line 3042 "reflect.h2"
+#line 3214 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void;
 
-#line 3053 "reflect.h2"
+#line 3225 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void;
 
-#line 3070 "reflect.h2"
+#line 3242 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void;
 
-#line 3081 "reflect.h2"
+#line 3253 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void;
 
-#line 3098 "reflect.h2"
+#line 3270 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void;
 
-#line 3109 "reflect.h2"
+#line 3281 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void;
 
-#line 3126 "reflect.h2"
+#line 3298 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void;
 
-#line 3138 "reflect.h2"
+#line 3310 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void;
 
-#line 3155 "reflect.h2"
+#line 3327 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void;
 
-#line 3166 "reflect.h2"
+#line 3338 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void;
 
-#line 3182 "reflect.h2"
+#line 3354 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void;
 
-#line 3193 "reflect.h2"
+#line 3365 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::expression_list> exprs) -> void;
 
-#line 3200 "reflect.h2"
+#line 3372 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void;
 
-#line 3216 "reflect.h2"
+#line 3388 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void;
 
-#line 3221 "reflect.h2"
+#line 3393 "reflect.h2"
     public: virtual auto pre_traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void;
 
-#line 3237 "reflect.h2"
+#line 3409 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void;
 
-#line 3256 "reflect.h2"
+#line 3428 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::unqualified_id> uid) -> void;
 
-#line 3262 "reflect.h2"
+#line 3434 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::qualified_id> qid) -> void;
 
-#line 3272 "reflect.h2"
+#line 3444 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::type_id> tid) -> void;
 
-#line 3289 "reflect.h2"
+#line 3461 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::primary_expression> primary) -> void;
 
-#line 3309 "reflect.h2"
+#line 3481 "reflect.h2"
     public: virtual auto traverse(cpp2::impl::in<meta::id_expression> idexpr) -> void;
     public: simple_traverser() = default;
     public: simple_traverser(simple_traverser const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(simple_traverser const&) -> void = delete;
 
 
-#line 3324 "reflect.h2"
+#line 3496 "reflect.h2"
 };
 
-#line 3337 "reflect.h2"
+#line 3509 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::declaration> decl, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3359 "reflect.h2"
+#line 3531 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::function_declaration> f, cpp2::impl::in<cpp2::i32> indent = 0) -> void;
 
-#line 3389 "reflect.h2"
+#line 3561 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::object_declaration> o, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3399 "reflect.h2"
+#line 3571 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::type_declaration> t, cpp2::impl::in<cpp2::i32> indent = 0) -> void;
 
-#line 3420 "reflect.h2"
+#line 3592 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::parameter_declaration> t, cpp2::impl::in<cpp2::i32> indent = 0) -> void;
 
-#line 3439 "reflect.h2"
+#line 3611 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3494 "reflect.h2"
+#line 3666 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::compound_statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3511 "reflect.h2"
+#line 3683 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::return_statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3521 "reflect.h2"
+#line 3693 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::iteration_statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3553 "reflect.h2"
+#line 3725 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::expression> expr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3567 "reflect.h2"
+#line 3739 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::assignment_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3597 "reflect.h2"
+#line 3769 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::logical_or_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3627 "reflect.h2"
+#line 3799 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::logical_and_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3657 "reflect.h2"
+#line 3829 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::bit_or_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3687 "reflect.h2"
+#line 3859 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::bit_xor_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3717 "reflect.h2"
+#line 3889 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::bit_and_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3747 "reflect.h2"
+#line 3919 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::equality_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3777 "reflect.h2"
+#line 3949 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::relational_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3807 "reflect.h2"
+#line 3979 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::compare_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3837 "reflect.h2"
+#line 4009 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::shift_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3867 "reflect.h2"
+#line 4039 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::additive_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3897 "reflect.h2"
+#line 4069 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::multiplicative_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3927 "reflect.h2"
+#line 4099 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::is_as_expression> isas, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3953 "reflect.h2"
+#line 4125 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::expression_list> exprs, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3968 "reflect.h2"
+#line 4140 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::prefix_expression> prefix, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 3992 "reflect.h2"
+#line 4164 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::postfix_expression> postfix, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 4025 "reflect.h2"
+#line 4197 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::unqualified_id> uid, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 4036 "reflect.h2"
+#line 4208 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::qualified_id> qid, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 4052 "reflect.h2"
+#line 4224 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::type_id> tid, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 4069 "reflect.h2"
+#line 4241 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::primary_expression> primary, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 4089 "reflect.h2"
+#line 4261 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in<cpp2::i32> indent) -> void;
 
-#line 4111 "reflect.h2"
+#line 4283 "reflect.h2"
 class autodiff_special_func {
            public: std::string name; 
            public: int n_args; 
@@ -1703,18 +1706,18 @@ class autodiff_special_func {
                           cpp2::impl::in<std::string> code_rws_ = "", cpp2::impl::in<std::string> code_primal_higher_order_ = "", cpp2::impl::in<std::string> code_fwd_higher_order_ = "", 
                           cpp2::impl::in<std::string> code_rws_higher_order_ = "");
 
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     public: autodiff_special_func(autodiff_special_func const& that);
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     public: auto operator=(autodiff_special_func const& that) -> autodiff_special_func& ;
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     public: autodiff_special_func(autodiff_special_func&& that) noexcept;
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     public: auto operator=(autodiff_special_func&& that) noexcept -> autodiff_special_func& ;
 
     public: [[nodiscard]] auto is_match(cpp2::impl::in<autodiff_special_func> o) const& -> bool;
 
-#line 4153 "reflect.h2"
+#line 4325 "reflect.h2"
 };
 
 class autodiff_declared_variable {
@@ -1727,13 +1730,13 @@ class autodiff_declared_variable {
 
     public: autodiff_declared_variable(cpp2::impl::in<std::string> name_, cpp2::impl::in<std::string> decl_, cpp2::impl::in<bool> is_active_, cpp2::impl::in<bool> is_member_);
 
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     public: autodiff_declared_variable(autodiff_declared_variable const& that);
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     public: auto operator=(autodiff_declared_variable const& that) -> autodiff_declared_variable& ;
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     public: autodiff_declared_variable(autodiff_declared_variable&& that) noexcept;
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     public: auto operator=(autodiff_declared_variable&& that) noexcept -> autodiff_declared_variable& ;
 };
 
@@ -1750,25 +1753,25 @@ class autodiff_declaration_stack_item {
 using lookup_declaration_ret = std::vector<meta::declaration>;
 
 
-#line 4187 "reflect.h2"
+#line 4359 "reflect.h2"
     public: [[nodiscard]] auto lookup_declaration(cpp2::impl::in<std::string> decl_name) const& -> lookup_declaration_ret;
 struct lookup_variable_declaration_ret { bool found; autodiff_declared_variable r; };
 
 
 
-#line 4197 "reflect.h2"
+#line 4369 "reflect.h2"
     public: [[nodiscard]] auto lookup_variable_declaration(cpp2::impl::in<std::string> decl_name) const& -> lookup_variable_declaration_ret;
     public: autodiff_declaration_stack_item(autodiff_declaration_stack_item const& that);
 public: autodiff_declaration_stack_item(autodiff_declaration_stack_item&& that) noexcept;
 
 
-#line 4215 "reflect.h2"
+#line 4387 "reflect.h2"
 };
 
 class autodiff_context {
     private: int temporary_count {0}; 
 
-#line 4227 "reflect.h2"
+#line 4399 "reflect.h2"
     public: std::vector<autodiff_special_func> special_funcs {
         autodiff_special_func("sin", 1,                   false, 
             "sin(_a1_)", 
@@ -1808,13 +1811,13 @@ class autodiff_context {
             "_od_.push_back(_ad1_);", 
             "TODO")}; 
 
-#line 4267 "reflect.h2"
+#line 4439 "reflect.h2"
             public: std::string fwd_suffix {"_d"}; 
             public: std::string rws_suffix {"_b"}; 
             private: int order {1}; 
             public: bool reverse {false}; 
 
-#line 4273 "reflect.h2"
+#line 4445 "reflect.h2"
     public: std::string fwd_ad_type {"double"}; 
     public: std::string rws_ad_type {"double"}; 
 
@@ -1824,94 +1827,94 @@ class autodiff_context {
     public: explicit autodiff_context();
     public: autodiff_context(cpp2::impl::in<int> order_, cpp2::impl::in<bool> reverse_);
 
-#line 4296 "reflect.h2"
+#line 4468 "reflect.h2"
     public: auto add_variable_declaration(cpp2::impl::in<std::string> name, cpp2::impl::in<std::string> type, cpp2::impl::in<bool> is_active, cpp2::impl::in<bool> is_member = false) & -> void;
 
-#line 4300 "reflect.h2"
+#line 4472 "reflect.h2"
     public: [[nodiscard]] auto is_variable_active(cpp2::impl::in<std::string> name) & -> bool;
 
-#line 4304 "reflect.h2"
+#line 4476 "reflect.h2"
     public: auto create_namespace_stack(cpp2::impl::in<meta::type_or_namespace_declaration> t) & -> void;
 
-#line 4321 "reflect.h2"
+#line 4493 "reflect.h2"
     public: [[nodiscard]] auto is_forward() const& -> decltype(auto);
     public: [[nodiscard]] auto is_reverse() const& -> decltype(auto);
     public: [[nodiscard]] auto is_taylor() const& -> decltype(auto);
 
     public: [[nodiscard]] auto gen_temporary() & -> std::string;
 
-#line 4330 "reflect.h2"
+#line 4502 "reflect.h2"
     public: [[nodiscard]] auto is_type_active(cpp2::impl::in<std::string> type) & -> bool;
 
-#line 4351 "reflect.h2"
+#line 4523 "reflect.h2"
     public: [[nodiscard]] auto get_fwd_ad_type(cpp2::impl::in<std::string> type) & -> std::string;
 
-#line 4369 "reflect.h2"
+#line 4541 "reflect.h2"
     public: [[nodiscard]] auto get_rws_ad_type(cpp2::impl::in<std::string> type) & -> std::string;
 
-#line 4387 "reflect.h2"
+#line 4559 "reflect.h2"
     public: [[nodiscard]] auto get_reverse_passing_style(cpp2::impl::in<passing_style> p) const& -> passing_style;
 using lookup_declaration_ret = std::vector<meta::declaration>;
 
 
-#line 4415 "reflect.h2"
+#line 4587 "reflect.h2"
     public: [[nodiscard]] auto lookup_declaration(cpp2::impl::in<std::string> decl_name) & -> lookup_declaration_ret;
 
-#line 4442 "reflect.h2"
+#line 4614 "reflect.h2"
     public: [[nodiscard]] auto lookup_variable_declaration(cpp2::impl::in<std::string> name) & -> autodiff_declared_variable;
 using lookup_function_declaration_ret = std::vector<meta::function_declaration>;
 
 
-#line 4464 "reflect.h2"
+#line 4636 "reflect.h2"
     public: [[nodiscard]] auto lookup_function_declaration(cpp2::impl::in<std::string> decl_name) & -> lookup_function_declaration_ret;
 using lookup_member_function_declaration_ret = std::vector<meta::function_declaration>;
 
 
-#line 4474 "reflect.h2"
+#line 4646 "reflect.h2"
     public: [[nodiscard]] auto lookup_member_function_declaration(cpp2::impl::in<meta::type_declaration> obj_type, cpp2::impl::in<std::string> decl_name) & -> lookup_member_function_declaration_ret;
 using lookup_type_declaration_ret = std::vector<meta::type_declaration>;
 
 
-#line 4484 "reflect.h2"
+#line 4656 "reflect.h2"
     public: [[nodiscard]] auto lookup_type_declaration(cpp2::impl::in<std::string> decl_name) & -> lookup_type_declaration_ret;
 struct lookup_special_function_handling_ret { bool m; std::string code_primal; std::string code_fwd; std::string code_rws; };
 
 
 
-#line 4494 "reflect.h2"
+#line 4666 "reflect.h2"
     public: [[nodiscard]] auto lookup_special_function_handling(cpp2::impl::in<std::string> func_name, cpp2::impl::in<int> n_args, cpp2::impl::in<bool> is_member) const& -> lookup_special_function_handling_ret;
 
-#line 4519 "reflect.h2"
+#line 4691 "reflect.h2"
     public: auto add_as_differentiated(cpp2::impl::in<meta::declaration> t) & -> void;
 
-#line 4527 "reflect.h2"
+#line 4699 "reflect.h2"
     public: auto add_for_differentiation(cpp2::impl::in<meta::declaration> t) & -> void;
 
-#line 4553 "reflect.h2"
+#line 4725 "reflect.h2"
     public: [[nodiscard]] static auto is_in_list(cpp2::impl::in<meta::declaration> v, cpp2::impl::in<std::vector<meta::declaration>> list) -> bool;
 
-#line 4563 "reflect.h2"
+#line 4735 "reflect.h2"
     public: auto enter_function() & -> void;
 
-#line 4568 "reflect.h2"
+#line 4740 "reflect.h2"
     public: auto leave_function() & -> void;
 
-#line 4572 "reflect.h2"
+#line 4744 "reflect.h2"
     public: auto push_stack(cpp2::impl::in<meta::type_or_namespace_declaration> decl) & -> void;
 
-#line 4585 "reflect.h2"
+#line 4757 "reflect.h2"
     public: auto pop_stack() & -> void;
 
-#line 4600 "reflect.h2"
+#line 4772 "reflect.h2"
     public: auto finish() & -> void;
 
-#line 4607 "reflect.h2"
+#line 4779 "reflect.h2"
     public: [[nodiscard]] auto get_self() & -> autodiff_context*;
     public: autodiff_context(autodiff_context const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(autodiff_context const&) -> void = delete;
 
 
-#line 4611 "reflect.h2"
+#line 4783 "reflect.h2"
 };
 
 class autodiff_diff_code {
@@ -1922,16 +1925,16 @@ class autodiff_diff_code {
     public: std::string rws_backprop {""}; 
 
     public: autodiff_diff_code(cpp2::impl::in<autodiff_context*> ctx_);
-#line 4620 "reflect.h2"
+#line 4792 "reflect.h2"
     public: auto operator=(cpp2::impl::in<autodiff_context*> ctx_) -> autodiff_diff_code& ;
 
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     public: autodiff_diff_code(autodiff_diff_code const& that);
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     public: auto operator=(autodiff_diff_code const& that) -> autodiff_diff_code& ;
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     public: autodiff_diff_code(autodiff_diff_code&& that) noexcept;
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     public: auto operator=(autodiff_diff_code&& that) noexcept -> autodiff_diff_code& ;
 
     public: auto add_forward(cpp2::impl::in<std::string> v) & -> void;
@@ -1940,46 +1943,46 @@ class autodiff_diff_code {
 
     public: auto reset() & -> void;
 
-#line 4636 "reflect.h2"
+#line 4808 "reflect.h2"
     public: auto operator=(cpp2::impl::in<std::string> v) -> autodiff_diff_code& ;
 
-#line 4642 "reflect.h2"
+#line 4814 "reflect.h2"
     public: auto operator+=(cpp2::impl::in<std::string> v) & -> void;
 
-#line 4647 "reflect.h2"
+#line 4819 "reflect.h2"
     public: auto operator+=(cpp2::impl::in<autodiff_diff_code> v) & -> void;
 
-#line 4652 "reflect.h2"
+#line 4824 "reflect.h2"
     public: [[nodiscard]] auto empty() const& -> bool;
 
-#line 4655 "reflect.h2"
+#line 4827 "reflect.h2"
 };
 
-#line 4662 "reflect.h2"
+#line 4834 "reflect.h2"
 class autodiff_activity_check: public simple_traverser {
 
-#line 4665 "reflect.h2"
+#line 4837 "reflect.h2"
            public: autodiff_context* ctx; 
            public: bool active {false}; 
 
     public: autodiff_activity_check(cpp2::impl::in<autodiff_context*> ctx_);
 
-#line 4672 "reflect.h2"
+#line 4844 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::type_declaration> t) -> void override;
 
-#line 4684 "reflect.h2"
+#line 4856 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::object_declaration> o) -> void override;
 
-#line 4702 "reflect.h2"
+#line 4874 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::primary_expression> primary) -> void override;
 
-#line 4726 "reflect.h2"
+#line 4898 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void override;
     public: autodiff_activity_check(autodiff_activity_check const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(autodiff_activity_check const&) -> void = delete;
 
 
-#line 4758 "reflect.h2"
+#line 4930 "reflect.h2"
 };
 
 class autodiff_handler_base {
@@ -1988,21 +1991,21 @@ class autodiff_handler_base {
     public: autodiff_diff_code diff; 
 
     public: autodiff_handler_base(cpp2::impl::in<autodiff_context*> ctx_);
-#line 4765 "reflect.h2"
+#line 4937 "reflect.h2"
     public: auto operator=(cpp2::impl::in<autodiff_context*> ctx_) -> autodiff_handler_base& ;
 
-#line 4771 "reflect.h2"
+#line 4943 "reflect.h2"
     public: auto append(autodiff_handler_base const& o) & -> void;
     public: autodiff_handler_base(autodiff_handler_base const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(autodiff_handler_base const&) -> void = delete;
 
 
-#line 4776 "reflect.h2"
+#line 4948 "reflect.h2"
 };
 
 class autodiff_expression_handler: public simple_traverser, public autodiff_handler_base {
 
-#line 4782 "reflect.h2"
+#line 4954 "reflect.h2"
     public: using base = simple_traverser;
 
     public: std::string primal_expr {""}; 
@@ -2011,33 +2014,33 @@ class autodiff_expression_handler: public simple_traverser, public autodiff_hand
 
     public: autodiff_expression_handler(cpp2::impl::in<autodiff_context*> ctx_);
 
-#line 4792 "reflect.h2"
+#line 4964 "reflect.h2"
     public: [[nodiscard]] auto add_suffix_if_not_wildcard(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> suffix) const& -> std::string;
 
-#line 4801 "reflect.h2"
+#line 4973 "reflect.h2"
     public: [[nodiscard]] auto prepare_backprop(cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b) const& -> std::string;
 
-#line 4809 "reflect.h2"
+#line 4981 "reflect.h2"
     public: [[nodiscard]] auto prepare_backprop(cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> lhs) const& -> std::string;
 
     public: auto gen_assignment(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> rhs, cpp2::impl::in<std::string> rhs_d, cpp2::impl::in<std::string> rhs_b) & -> void;
 
-#line 4822 "reflect.h2"
+#line 4994 "reflect.h2"
     public: [[nodiscard]] auto gen_assignment(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b) & -> decltype(auto);
 
     public: [[nodiscard]] auto gen_assignment(cpp2::impl::in<std::string> lhs) & -> decltype(auto);
 
-#line 4828 "reflect.h2"
+#line 5000 "reflect.h2"
     public: auto gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> rhs, cpp2::impl::in<std::string> rhs_d, cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> type, cpp2::impl::in<std::string> type_d, cpp2::impl::in<std::string> type_b) & -> void;
 
-#line 4840 "reflect.h2"
+#line 5012 "reflect.h2"
     public: [[nodiscard]] auto gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> rhs, cpp2::impl::in<std::string> rhs_d, cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> type) & -> decltype(auto);
 
     public: [[nodiscard]] auto gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> type) & -> decltype(auto);
 
     public: [[nodiscard]] auto gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> type) & -> decltype(auto);
 
-#line 4849 "reflect.h2"
+#line 5021 "reflect.h2"
     public: class primal_fwd_rws_name {
         public: std::string primal {""}; 
         public: std::string fwd {""}; 
@@ -2046,80 +2049,80 @@ class autodiff_expression_handler: public simple_traverser, public autodiff_hand
         public: primal_fwd_rws_name(auto const& primal_, auto const& fwd_, auto const& rws_, auto const& active_);
 public: primal_fwd_rws_name();
 
-#line 4854 "reflect.h2"
+#line 5026 "reflect.h2"
     };
 
     public: [[nodiscard]] auto handle_expression_list(cpp2::impl::in<meta::expression_list> list) & -> std::vector<primal_fwd_rws_name>;
 
-#line 4865 "reflect.h2"
+#line 5037 "reflect.h2"
     public: [[nodiscard]] auto handle_expression_term(auto const& term) & -> primal_fwd_rws_name;
 
-#line 4926 "reflect.h2"
+#line 5098 "reflect.h2"
     public: auto handle_function_call(cpp2::impl::in<meta::postfix_expression> postfix, cpp2::impl::in<bool> has_return) & -> void;
 
-#line 5106 "reflect.h2"
+#line 5278 "reflect.h2"
     public: [[nodiscard]] auto handle_special_function(cpp2::impl::in<std::string> object, cpp2::impl::in<std::string> object_d, cpp2::impl::in<std::string> object_b, cpp2::impl::in<std::string> function_name, cpp2::impl::in<std::vector<primal_fwd_rws_name>> args) & -> bool;
 
-#line 5151 "reflect.h2"
+#line 5323 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::expression> expr) -> void override;
 
-#line 5155 "reflect.h2"
+#line 5327 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void override;
 
-#line 5159 "reflect.h2"
+#line 5331 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void override;
 
-#line 5163 "reflect.h2"
+#line 5335 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void override;
 
-#line 5167 "reflect.h2"
+#line 5339 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void override;
 
-#line 5171 "reflect.h2"
+#line 5343 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void override;
 
-#line 5175 "reflect.h2"
+#line 5347 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void override;
 
-#line 5179 "reflect.h2"
+#line 5351 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void override;
 
-#line 5183 "reflect.h2"
+#line 5355 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void override;
 
-#line 5187 "reflect.h2"
+#line 5359 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void override;
 
-#line 5191 "reflect.h2"
+#line 5363 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void override;
 
-#line 5195 "reflect.h2"
+#line 5367 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void override;
 
-#line 5237 "reflect.h2"
+#line 5409 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void override;
 
-#line 5324 "reflect.h2"
+#line 5496 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void override;
 
-#line 5328 "reflect.h2"
+#line 5500 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void override;
 
-#line 5344 "reflect.h2"
+#line 5516 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void override;
 
-#line 5384 "reflect.h2"
+#line 5556 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::primary_expression> primary) -> void override;
     public: autodiff_expression_handler(autodiff_expression_handler const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(autodiff_expression_handler const&) -> void = delete;
 
 
-#line 5419 "reflect.h2"
+#line 5591 "reflect.h2"
 };
 
 class autodiff_stmt_handler: public simple_traverser, public autodiff_handler_base {
 
-#line 5425 "reflect.h2"
+#line 5597 "reflect.h2"
     public: using base = simple_traverser;
 
     private: meta::function_declaration mf; 
@@ -2131,102 +2134,102 @@ class autodiff_stmt_handler: public simple_traverser, public autodiff_handler_ba
 
     public: autodiff_stmt_handler(cpp2::impl::in<autodiff_context*> ctx_, cpp2::impl::in<meta::function_declaration> mf_);
 
-#line 5439 "reflect.h2"
+#line 5611 "reflect.h2"
     public: [[nodiscard]] auto handle_stmt_parameters(cpp2::impl::in<std::vector<parameter_declaration>> params) & -> autodiff_diff_code;
 
-#line 5481 "reflect.h2"
+#line 5653 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::declaration> decl) -> void override;
 
-#line 5486 "reflect.h2"
+#line 5658 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::function_declaration> f) -> void override;
 
-#line 5491 "reflect.h2"
+#line 5663 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::object_declaration> o) -> void override;
 
-#line 5553 "reflect.h2"
+#line 5725 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::type_declaration> t) -> void override;
 
-#line 5558 "reflect.h2"
+#line 5730 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void override;
 
-#line 5563 "reflect.h2"
+#line 5735 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::statement> stmt) -> void override;
 
-#line 5570 "reflect.h2"
+#line 5742 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::compound_statement> stmt) -> void override;
 
-#line 5605 "reflect.h2"
+#line 5777 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::return_statement> stmt) -> void override;
 
-#line 5621 "reflect.h2"
+#line 5793 "reflect.h2"
     public: [[nodiscard]] auto reverse_next(cpp2::impl::in<std::string> expr) const& -> std::string;
 
-#line 5636 "reflect.h2"
+#line 5808 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::iteration_statement> stmt) -> void override;
 
-#line 5734 "reflect.h2"
+#line 5906 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::selection_statement> stmt) -> void override;
 
-#line 5745 "reflect.h2"
+#line 5917 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::expression> expr) -> void override;
 
-#line 5749 "reflect.h2"
+#line 5921 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void override;
 
-#line 5800 "reflect.h2"
+#line 5972 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void override;
 
-#line 5804 "reflect.h2"
+#line 5976 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void override;
 
-#line 5808 "reflect.h2"
+#line 5980 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void override;
 
-#line 5812 "reflect.h2"
+#line 5984 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void override;
 
-#line 5816 "reflect.h2"
+#line 5988 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void override;
 
-#line 5820 "reflect.h2"
+#line 5992 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void override;
 
-#line 5824 "reflect.h2"
+#line 5996 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void override;
 
-#line 5828 "reflect.h2"
+#line 6000 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void override;
 
-#line 5832 "reflect.h2"
+#line 6004 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void override;
 
-#line 5836 "reflect.h2"
+#line 6008 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void override;
 
-#line 5840 "reflect.h2"
+#line 6012 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void override;
 
-#line 5844 "reflect.h2"
+#line 6016 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void override;
 
-#line 5848 "reflect.h2"
+#line 6020 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void override;
 
-#line 5853 "reflect.h2"
+#line 6025 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void override;
 
-#line 5885 "reflect.h2"
+#line 6057 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::primary_expression> primary) -> void override;
     public: autodiff_stmt_handler(autodiff_stmt_handler const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(autodiff_stmt_handler const&) -> void = delete;
 
 
-#line 5889 "reflect.h2"
+#line 6061 "reflect.h2"
 };
 
 class autodiff_declaration_handler: public simple_traverser, public autodiff_handler_base {
 
-#line 5895 "reflect.h2"
+#line 6067 "reflect.h2"
     public: using base = simple_traverser;
 
     private: meta::type_or_namespace_declaration decl; 
@@ -2236,37 +2239,37 @@ class autodiff_declaration_handler: public simple_traverser, public autodiff_han
 
     public: autodiff_declaration_handler(cpp2::impl::in<autodiff_context*> ctx_, cpp2::impl::in<meta::type_or_namespace_declaration> decl_);
 
-#line 5907 "reflect.h2"
+#line 6079 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::declaration> decl_) -> void override;
 
-#line 5912 "reflect.h2"
+#line 6084 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::function_declaration> f) -> void override;
 
-#line 6070 "reflect.h2"
+#line 6242 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::object_declaration> o) -> void override;
 
-#line 6098 "reflect.h2"
+#line 6270 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::type_declaration> t) -> void override;
 
-#line 6122 "reflect.h2"
+#line 6294 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void override;
 
-#line 6127 "reflect.h2"
+#line 6299 "reflect.h2"
     public: auto traverse(cpp2::impl::in<meta::statement> stmt) -> void override;
     public: autodiff_declaration_handler(autodiff_declaration_handler const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(autodiff_declaration_handler const&) -> void = delete;
 
 
-#line 6130 "reflect.h2"
+#line 6302 "reflect.h2"
 };
 
-#line 6133 "reflect.h2"
+#line 6305 "reflect.h2"
 auto autodiff(meta::type_declaration& t) -> void;
 
-#line 6239 "reflect.h2"
+#line 6411 "reflect.h2"
 using error_func = std::function<void(cpp2::impl::in<std::string> x)>;
 
-#line 6243 "reflect.h2"
+#line 6415 "reflect.h2"
 class expression_flags
  {
 private: cpp2::u8 _value; private: constexpr expression_flags(cpp2::impl::in<cpp2::i64> _val);
@@ -2301,20 +2304,20 @@ public: [[nodiscard]] auto to_code() const& -> std::string;
 public: [[nodiscard]] static auto from_string(cpp2::impl::in<std::string_view> s) -> expression_flags;
 public: [[nodiscard]] static auto from_code(cpp2::impl::in<std::string_view> s) -> expression_flags;
 
-#line 6251 "reflect.h2"
+#line 6423 "reflect.h2"
 };
 
-#line 6259 "reflect.h2"
+#line 6431 "reflect.h2"
 class regex_token
  {
     public: std::string string_rep; 
 
     public: regex_token(cpp2::impl::in<std::string> str);
 
-#line 6267 "reflect.h2"
+#line 6439 "reflect.h2"
     public: explicit regex_token();
 
-#line 6272 "reflect.h2"
+#line 6444 "reflect.h2"
     public: virtual auto generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void = 0;
     public: [[nodiscard]] virtual auto reverse() const -> std::shared_ptr<regex_token> = 0;
 
@@ -2326,103 +2329,103 @@ class regex_token
     public: regex_token(regex_token const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(regex_token const&) -> void = delete;
 
-#line 6278 "reflect.h2"
+#line 6450 "reflect.h2"
 };
 
 using token_ptr = std::shared_ptr<regex_token>;
 using token_vec = std::vector<token_ptr>;
 
-#line 6284 "reflect.h2"
+#line 6456 "reflect.h2"
 //  Adds a check in code generation.
 //
 class regex_token_check
 : public regex_token {
 
-#line 6290 "reflect.h2"
+#line 6462 "reflect.h2"
     private: std::string check; 
 
     public: regex_token_check(cpp2::impl::in<std::string> str, cpp2::impl::in<std::string> check_);
 
-#line 6297 "reflect.h2"
+#line 6469 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 6301 "reflect.h2"
+#line 6473 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
     public: virtual ~regex_token_check() noexcept;
 
     public: regex_token_check(regex_token_check const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(regex_token_check const&) -> void = delete;
 
-#line 6302 "reflect.h2"
+#line 6474 "reflect.h2"
 };
 
-#line 6305 "reflect.h2"
+#line 6477 "reflect.h2"
 //  Adds code in code generation.
 //
 class regex_token_code
 : public regex_token {
 
-#line 6311 "reflect.h2"
+#line 6483 "reflect.h2"
     private: std::string code; 
 
     public: regex_token_code(cpp2::impl::in<std::string> str, cpp2::impl::in<std::string> code_);
 
-#line 6318 "reflect.h2"
+#line 6490 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 6322 "reflect.h2"
+#line 6494 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
     public: virtual ~regex_token_code() noexcept;
 
     public: regex_token_code(regex_token_code const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(regex_token_code const&) -> void = delete;
 
-#line 6323 "reflect.h2"
+#line 6495 "reflect.h2"
 };
 
-#line 6326 "reflect.h2"
+#line 6498 "reflect.h2"
 //  Token that does not influence the matching. E.g. comment.
 //
 class regex_token_empty
 : public regex_token {
 
-#line 6332 "reflect.h2"
+#line 6504 "reflect.h2"
     public: regex_token_empty(cpp2::impl::in<std::string> str);
 
-#line 6336 "reflect.h2"
+#line 6508 "reflect.h2"
     public: auto generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void override;
 
-#line 6340 "reflect.h2"
+#line 6512 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
     public: virtual ~regex_token_empty() noexcept;
 
     public: regex_token_empty(regex_token_empty const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(regex_token_empty const&) -> void = delete;
 
-#line 6341 "reflect.h2"
+#line 6513 "reflect.h2"
 };
 
-#line 6344 "reflect.h2"
+#line 6516 "reflect.h2"
 //  Represents a list of regex tokens as one token.
 //
 class regex_token_list
 : public regex_token {
 
-#line 6350 "reflect.h2"
+#line 6522 "reflect.h2"
     public: token_vec tokens; 
 
     public: regex_token_list(cpp2::impl::in<token_vec> t);
 
-#line 6357 "reflect.h2"
+#line 6529 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 6363 "reflect.h2"
+#line 6535 "reflect.h2"
     public: auto add_groups(std::set<int>& groups) const -> void override;
 
-#line 6369 "reflect.h2"
+#line 6541 "reflect.h2"
     public: [[nodiscard]] static auto gen_string(cpp2::impl::in<token_vec> vec) -> std::string;
 
-#line 6377 "reflect.h2"
+#line 6549 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
     public: virtual ~regex_token_list() noexcept;
 
@@ -2430,10 +2433,10 @@ class regex_token_list
     public: auto operator=(regex_token_list const&) -> void = delete;
 
 
-#line 6389 "reflect.h2"
+#line 6561 "reflect.h2"
 };
 
-#line 6392 "reflect.h2"
+#line 6564 "reflect.h2"
 //
 //  Parse and generation context.
 //
@@ -2449,33 +2452,33 @@ class parse_context_group_state
     //  Start a new alternative.
     public: auto next_alternative() & -> void;
 
-#line 6412 "reflect.h2"
+#line 6584 "reflect.h2"
     //  Swap this state with the other one. NOLINTNEXTLINE(performance-noexcept-swap)
     public: auto swap(parse_context_group_state& t) & -> void;
 
-#line 6419 "reflect.h2"
+#line 6591 "reflect.h2"
     //  Convert this state into a regex token.
     public: [[nodiscard]] auto get_as_token() & -> token_ptr;
 
-#line 6431 "reflect.h2"
+#line 6603 "reflect.h2"
     //  Add a token to the current matcher list.
     public: auto add(cpp2::impl::in<token_ptr> token) & -> void;
 
-#line 6436 "reflect.h2"
+#line 6608 "reflect.h2"
     //  True if current matcher list is empty.
     public: [[nodiscard]] auto empty() const& -> bool;
 
-#line 6440 "reflect.h2"
+#line 6612 "reflect.h2"
     //  Apply optimizations to the matcher list.
     public: static auto post_process_list(token_vec& list) -> void;
     public: parse_context_group_state(auto const& cur_match_list_, auto const& alternate_match_lists_, auto const& modifiers_);
 public: parse_context_group_state();
 
 
-#line 6454 "reflect.h2"
+#line 6626 "reflect.h2"
 };
 
-#line 6457 "reflect.h2"
+#line 6629 "reflect.h2"
 //  State for the branch reset. Takes care of the group numbering. See '(|<pattern>)'.
 //
 class parse_context_branch_reset_state
@@ -2488,25 +2491,25 @@ class parse_context_branch_reset_state
     //  Next group identifier.
     public: [[nodiscard]] auto next() & -> int;
 
-#line 6475 "reflect.h2"
+#line 6647 "reflect.h2"
     //  Set next group identifier.
     public: auto set_next(cpp2::impl::in<int> g) & -> void;
 
-#line 6481 "reflect.h2"
+#line 6653 "reflect.h2"
     //  Start a new alternative branch.
     public: auto next_alternative() & -> void;
 
-#line 6488 "reflect.h2"
+#line 6660 "reflect.h2"
     //  Initialize for a branch reset group.
     public: auto set_active_reset(cpp2::impl::in<int> restart) & -> void;
     public: parse_context_branch_reset_state(auto const& is_active_, auto const& cur_group_, auto const& max_group_, auto const& from_);
 public: parse_context_branch_reset_state();
 
 
-#line 6495 "reflect.h2"
+#line 6667 "reflect.h2"
 };
 
-#line 6498 "reflect.h2"
+#line 6670 "reflect.h2"
 //  Context during parsing of the regular expressions.
 // 
 //  Keeps track of the distributed group identifiers, current parsed group and branch resets.
@@ -2522,7 +2525,7 @@ class parse_context
     private: parse_context_group_state cur_group_state {}; 
     private: parse_context_branch_reset_state cur_branch_reset_state {}; 
 
-#line 6514 "reflect.h2"
+#line 6686 "reflect.h2"
            public: std::map<std::string,int> named_groups {}; 
 
     private: error_func error_out; // TODO: Declaring std::function<void(std::string)> fails for cpp2.
@@ -2530,64 +2533,64 @@ class parse_context
 
     public: parse_context(cpp2::impl::in<std::string_view> r, auto const& e);
 
-#line 6525 "reflect.h2"
+#line 6697 "reflect.h2"
     //  State management functions
     //
 
     //  Returned group state needs to be stored and provided in `end_group`.
     public: [[nodiscard]] auto start_group() & -> parse_context_group_state;
 
-#line 6538 "reflect.h2"
+#line 6710 "reflect.h2"
     //  `old_state` argument needs to be from start group.
     public: [[nodiscard]] auto end_group(cpp2::impl::in<parse_context_group_state> old_state) & -> token_ptr;
 
-#line 6546 "reflect.h2"
+#line 6718 "reflect.h2"
     public: [[nodiscard]] auto get_modifiers() const& -> expression_flags;
 
-#line 6550 "reflect.h2"
+#line 6722 "reflect.h2"
     public: auto set_modifiers(cpp2::impl::in<expression_flags> mod) & -> void;
 
-#line 6554 "reflect.h2"
+#line 6726 "reflect.h2"
     //  Branch reset management functions
     //
 
     public: [[nodiscard]] auto branch_reset_new_state() & -> parse_context_branch_reset_state;
 
-#line 6566 "reflect.h2"
+#line 6738 "reflect.h2"
     public: auto branch_reset_restore_state(cpp2::impl::in<parse_context_branch_reset_state> old_state) & -> void;
 
-#line 6573 "reflect.h2"
+#line 6745 "reflect.h2"
     public: auto next_alternative() & -> void;
 
-#line 6579 "reflect.h2"
+#line 6751 "reflect.h2"
     //  Regex token management
     //
     public: auto add_token(cpp2::impl::in<token_ptr> token) & -> void;
 
-#line 6585 "reflect.h2"
+#line 6757 "reflect.h2"
     public: [[nodiscard]] auto has_token() const& -> bool;
 
-#line 6589 "reflect.h2"
+#line 6761 "reflect.h2"
     public: [[nodiscard]] auto pop_token() & -> token_ptr;
 
-#line 6600 "reflect.h2"
+#line 6772 "reflect.h2"
     public: [[nodiscard]] auto get_as_token() & -> token_ptr;
 
-#line 6604 "reflect.h2"
+#line 6776 "reflect.h2"
     //  Group management
     //
     public: [[nodiscard]] auto get_cur_group() const& -> int;
 
-#line 6610 "reflect.h2"
+#line 6782 "reflect.h2"
     public: [[nodiscard]] auto next_group() & -> int;
 
-#line 6614 "reflect.h2"
+#line 6786 "reflect.h2"
     public: auto set_named_group(cpp2::impl::in<std::string> name, cpp2::impl::in<int> id) & -> void;
 
-#line 6621 "reflect.h2"
+#line 6793 "reflect.h2"
     public: [[nodiscard]] auto get_named_group(cpp2::impl::in<std::string> name) const& -> int;
 
-#line 6632 "reflect.h2"
+#line 6804 "reflect.h2"
     //  Position management functions
     //
     public: [[nodiscard]] auto current() const& -> char;
@@ -2595,51 +2598,51 @@ class parse_context
     //  Get the next token in the regex, skipping spaces according to the parameters. See `x` and `xx` modifiers.
     private: [[nodiscard]] auto get_next_position(cpp2::impl::in<bool> in_class, cpp2::impl::in<bool> no_skip) const& -> size_t;
 
-#line 6676 "reflect.h2"
+#line 6848 "reflect.h2"
     //  Return true if next token is available.
     private: [[nodiscard]] auto next_impl(cpp2::impl::in<bool> in_class, cpp2::impl::in<bool> no_skip) & -> bool;
 
-#line 6688 "reflect.h2"
+#line 6860 "reflect.h2"
     public: [[nodiscard]] auto next() & -> decltype(auto);
     public: [[nodiscard]] auto next_in_class() & -> decltype(auto);
     public: [[nodiscard]] auto next_no_skip() & -> decltype(auto);
 
     public: [[nodiscard]] auto next_n(cpp2::impl::in<int> n) & -> bool;
 
-#line 6701 "reflect.h2"
+#line 6873 "reflect.h2"
     public: [[nodiscard]] auto has_next() const& -> bool;
 
     private: [[nodiscard]] auto grab_until_impl(cpp2::impl::in<std::string> e, cpp2::impl::out<std::string> r, cpp2::impl::in<bool> any) & -> bool;
 
-#line 6724 "reflect.h2"
+#line 6896 "reflect.h2"
     public: [[nodiscard]] auto grab_until(cpp2::impl::in<std::string> e, cpp2::impl::out<std::string> r) & -> decltype(auto);
     public: [[nodiscard]] auto grab_until(cpp2::impl::in<char> e, cpp2::impl::out<std::string> r) & -> decltype(auto);
     public: [[nodiscard]] auto grab_until_one_of(cpp2::impl::in<std::string> e, cpp2::impl::out<std::string> r) & -> decltype(auto);
 
     public: [[nodiscard]] auto grab_n(cpp2::impl::in<int> n, cpp2::impl::out<std::string> r) & -> bool;
 
-#line 6741 "reflect.h2"
+#line 6913 "reflect.h2"
     public: [[nodiscard]] auto grab_number() & -> std::string;
 
-#line 6762 "reflect.h2"
+#line 6934 "reflect.h2"
     private: [[nodiscard]] auto peek_impl(cpp2::impl::in<bool> in_class) const& -> char;
 
-#line 6772 "reflect.h2"
+#line 6944 "reflect.h2"
     public: [[nodiscard]] auto peek() const& -> decltype(auto);
     public: [[nodiscard]] auto peek_in_class() const& -> decltype(auto);
 
-#line 6776 "reflect.h2"
+#line 6948 "reflect.h2"
     //  Parsing functions
     //
     public: [[nodiscard]] auto parser_group_modifiers(cpp2::impl::in<std::string> change_str, expression_flags& parser_modifiers) & -> bool;
 
-#line 6832 "reflect.h2"
+#line 7004 "reflect.h2"
     public: [[nodiscard]] auto parse_until(cpp2::impl::in<char> term) & -> bool;
 
-#line 6871 "reflect.h2"
+#line 7043 "reflect.h2"
     public: [[nodiscard]] auto parse(cpp2::impl::in<std::string> modifiers) & -> bool;
 
-#line 6886 "reflect.h2"
+#line 7058 "reflect.h2"
     //  Misc functions
 
     public: [[nodiscard]] auto get_pos() const& -> decltype(auto);
@@ -2651,10 +2654,10 @@ class parse_context
     public: auto operator=(parse_context const&) -> void = delete;
 
 
-#line 6897 "reflect.h2"
+#line 7069 "reflect.h2"
 };
 
-#line 6900 "reflect.h2"
+#line 7072 "reflect.h2"
 //  Context for one function generation. Generation of functions can be interleaved,
 //  therefore we buffer the code for one function here.
 //
@@ -2664,16 +2667,16 @@ class generation_function_context {
 
     public: auto add_tabs(cpp2::impl::in<int> c) & -> void;
 
-#line 6914 "reflect.h2"
+#line 7086 "reflect.h2"
     public: auto remove_tabs(cpp2::impl::in<int> c) & -> void;
     public: generation_function_context(auto const& code_, auto const& tabs_);
 public: generation_function_context();
 
 
-#line 6917 "reflect.h2"
+#line 7089 "reflect.h2"
 };
 
-#line 6920 "reflect.h2"
+#line 7092 "reflect.h2"
 //  Context for generating the state machine.
 class generation_context
  {
@@ -2693,68 +2696,68 @@ class generation_context
     //  Add code line.
     public: auto add(cpp2::impl::in<std::string> s) & -> void;
 
-#line 6942 "reflect.h2"
+#line 7114 "reflect.h2"
     //  Add check for token. The check needs to be a function call that returns a boolean.
     public: auto add_check(cpp2::impl::in<std::string> check) & -> void;
 
-#line 6948 "reflect.h2"
+#line 7120 "reflect.h2"
     //  Add a stateful check. The check needs to return a `match_return`.
     public: auto add_statefull(cpp2::impl::in<std::string> next_func, cpp2::impl::in<std::string> check) & -> void;
 
-#line 6957 "reflect.h2"
+#line 7129 "reflect.h2"
     protected: auto start_func_named(cpp2::impl::in<std::string> name) & -> void;
 
-#line 6968 "reflect.h2"
+#line 7140 "reflect.h2"
     protected: [[nodiscard]] auto start_func() & -> std::string;
 
-#line 6975 "reflect.h2"
+#line 7147 "reflect.h2"
     protected: auto end_func_statefull(cpp2::impl::in<std::string> s) & -> void;
 
-#line 6995 "reflect.h2"
+#line 7167 "reflect.h2"
     //  Generate the function for a token.
     public: [[nodiscard]] auto generate_func(cpp2::impl::in<token_ptr> token) & -> std::string;
 
-#line 7005 "reflect.h2"
+#line 7177 "reflect.h2"
     //  Generate the reset for a list of group identifiers.
     public: [[nodiscard]] auto generate_reset(cpp2::impl::in<std::set<int>> groups) & -> std::string;
 
-#line 7028 "reflect.h2"
+#line 7200 "reflect.h2"
     //  Name generation
     //
     protected: [[nodiscard]] auto gen_func_name() & -> std::string;
 
-#line 7036 "reflect.h2"
+#line 7208 "reflect.h2"
     public: [[nodiscard]] auto next_func_name() & -> std::string;
 
-#line 7040 "reflect.h2"
+#line 7212 "reflect.h2"
     protected: [[nodiscard]] auto gen_reset_func_name() & -> std::string;
 
-#line 7046 "reflect.h2"
+#line 7218 "reflect.h2"
     public: [[nodiscard]] auto gen_temp() & -> std::string;
 
-#line 7052 "reflect.h2"
+#line 7224 "reflect.h2"
     //  Context management
     //
     public: [[nodiscard]] auto new_context() & -> generation_function_context*;
 
-#line 7062 "reflect.h2"
+#line 7234 "reflect.h2"
     public: auto finish_context() & -> void;
 
-#line 7070 "reflect.h2"
+#line 7242 "reflect.h2"
     //  Misc functions
     //
     private: [[nodiscard]] auto get_current() & -> generation_function_context*;
 
-#line 7076 "reflect.h2"
+#line 7248 "reflect.h2"
     private: [[nodiscard]] auto get_base() & -> generation_function_context*;
 
-#line 7080 "reflect.h2"
+#line 7252 "reflect.h2"
     public: [[nodiscard]] auto get_entry_func() const& -> std::string;
 
-#line 7084 "reflect.h2"
+#line 7256 "reflect.h2"
     public: [[nodiscard]] auto create_named_group_lookup(cpp2::impl::in<std::map<std::string,int>> named_groups) const& -> std::string;
 
-#line 7108 "reflect.h2"
+#line 7280 "reflect.h2"
     //  Run the generation for the token.
     public: [[nodiscard]] auto run(cpp2::impl::in<token_ptr> token) & -> std::string;
     public: generation_context() = default;
@@ -2762,7 +2765,7 @@ class generation_context
     public: auto operator=(generation_context const&) -> void = delete;
 
 
-#line 7114 "reflect.h2"
+#line 7286 "reflect.h2"
 };
 
 //  Regex syntax: |  Example: ab|ba
@@ -2782,27 +2785,27 @@ class alternative_token
     public: auto operator=(alternative_token const&) -> void = delete;
 
 
-#line 7133 "reflect.h2"
+#line 7305 "reflect.h2"
 };
 
 class alternative_token_gen
 : public regex_token {
 
-#line 7139 "reflect.h2"
+#line 7311 "reflect.h2"
     private: token_vec alternatives; 
 
     public: alternative_token_gen(cpp2::impl::in<token_vec> a);
 
-#line 7146 "reflect.h2"
+#line 7318 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 7163 "reflect.h2"
+#line 7335 "reflect.h2"
     public: auto add_groups(std::set<int>& groups) const -> void override;
 
-#line 7170 "reflect.h2"
+#line 7342 "reflect.h2"
     public: [[nodiscard]] static auto gen_string(cpp2::impl::in<token_vec> a) -> std::string;
 
-#line 7183 "reflect.h2"
+#line 7355 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
     public: virtual ~alternative_token_gen() noexcept;
 
@@ -2810,19 +2813,19 @@ class alternative_token_gen
     public: auto operator=(alternative_token_gen const&) -> void = delete;
 
 
-#line 7195 "reflect.h2"
+#line 7367 "reflect.h2"
 };
 
-#line 7198 "reflect.h2"
+#line 7370 "reflect.h2"
 //  Regex syntax: .
 //
 class any_token
 : public regex_token_check {
 
-#line 7204 "reflect.h2"
+#line 7376 "reflect.h2"
     public: any_token(cpp2::impl::in<bool> single_line);
 
-#line 7208 "reflect.h2"
+#line 7380 "reflect.h2"
     public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr;
     public: virtual ~any_token() noexcept;
 
@@ -2830,7 +2833,7 @@ class any_token
     public: auto operator=(any_token const&) -> void = delete;
 
 
-#line 7213 "reflect.h2"
+#line 7385 "reflect.h2"
 };
 
 //  Regex syntax: (?><matcher>)  Example: a(?>bc|c)c
@@ -2838,17 +2841,17 @@ class any_token
 class atomic_group_token
 : public regex_token {
 
-#line 7221 "reflect.h2"
+#line 7393 "reflect.h2"
             public: token_ptr inner_token {nullptr}; 
 
     public: explicit atomic_group_token();
 
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
 
-#line 7232 "reflect.h2"
+#line 7404 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 7240 "reflect.h2"
+#line 7412 "reflect.h2"
     public: auto add_groups(std::set<int>& groups) const -> void override;
     public: virtual ~atomic_group_token() noexcept;
 
@@ -2856,7 +2859,7 @@ class atomic_group_token
     public: auto operator=(atomic_group_token const&) -> void = delete;
 
 
-#line 7243 "reflect.h2"
+#line 7415 "reflect.h2"
 };
 
 //  Regex syntax: a
@@ -2864,34 +2867,34 @@ class atomic_group_token
 class char_token
 : public regex_token {
 
-#line 7251 "reflect.h2"
+#line 7423 "reflect.h2"
     private: std::string token; 
     private: bool ignore_case; 
 
     public: char_token(cpp2::impl::in<char> t, cpp2::impl::in<bool> ignore_case_);
 
-#line 7260 "reflect.h2"
+#line 7432 "reflect.h2"
     public: char_token(cpp2::impl::in<std::string> t, cpp2::impl::in<bool> ignore_case_);
 
-#line 7266 "reflect.h2"
+#line 7438 "reflect.h2"
     public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr;
 
-#line 7270 "reflect.h2"
+#line 7442 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 7293 "reflect.h2"
+#line 7465 "reflect.h2"
     public: auto gen_case_insensitive(cpp2::impl::in<std::string> lower, cpp2::impl::in<std::string> upper, generation_context& ctx) const& -> void;
 
-#line 7314 "reflect.h2"
+#line 7486 "reflect.h2"
     public: auto gen_case_sensitive(generation_context& ctx) const& -> void;
 
-#line 7332 "reflect.h2"
+#line 7504 "reflect.h2"
     public: [[nodiscard]] auto add_escapes(std::string str) const& -> std::string;
 
-#line 7347 "reflect.h2"
+#line 7519 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
 
-#line 7353 "reflect.h2"
+#line 7525 "reflect.h2"
     public: auto append(char_token const& that) & -> void;
     public: virtual ~char_token() noexcept;
 
@@ -2899,33 +2902,33 @@ class char_token
     public: auto operator=(char_token const&) -> void = delete;
 
 
-#line 7357 "reflect.h2"
+#line 7529 "reflect.h2"
 };
 
-#line 7360 "reflect.h2"
+#line 7532 "reflect.h2"
 //  Regex syntax: [<character classes>]  Example: [abcx-y[:digits:]]
 //
 class class_token
 : public regex_token {
 
-#line 7366 "reflect.h2"
+#line 7538 "reflect.h2"
     private: bool negate; 
     private: bool case_insensitive; 
     private: std::string class_str; 
 
     public: class_token(cpp2::impl::in<bool> negate_, cpp2::impl::in<bool> case_insensitive_, cpp2::impl::in<std::string> class_str_, cpp2::impl::in<std::string> str);
 
-#line 7378 "reflect.h2"
+#line 7550 "reflect.h2"
     //  TODO: Rework class generation: Generate check functions for classes.
     public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr;
 
-#line 7504 "reflect.h2"
+#line 7676 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
 
-#line 7513 "reflect.h2"
+#line 7685 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 7518 "reflect.h2"
+#line 7690 "reflect.h2"
     private: [[nodiscard]] static auto create_matcher(cpp2::impl::in<std::string> name, cpp2::impl::in<std::string> template_arguments) -> std::string;
     public: virtual ~class_token() noexcept;
 
@@ -2933,20 +2936,20 @@ class class_token
     public: auto operator=(class_token const&) -> void = delete;
 
 
-#line 7525 "reflect.h2"
+#line 7697 "reflect.h2"
 };
 
-#line 7528 "reflect.h2"
+#line 7700 "reflect.h2"
 //  Regex syntax: \a or \n or \[
 //
 [[nodiscard]] auto escape_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 7569 "reflect.h2"
+#line 7741 "reflect.h2"
 //  Regex syntax: \K Example: ab\Kcd
 //
 [[nodiscard]] auto global_group_reset_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 7580 "reflect.h2"
+#line 7752 "reflect.h2"
 //  Regex syntax: \<number>  Example: \1
 //                \g{name_or_number}
 //                \k{name_or_number}
@@ -2956,20 +2959,20 @@ class class_token
 class group_ref_token
 : public regex_token {
 
-#line 7590 "reflect.h2"
+#line 7762 "reflect.h2"
     private: int id; 
     private: bool case_insensitive; 
     private: bool reverse_eval; 
 
     public: group_ref_token(cpp2::impl::in<int> id_, cpp2::impl::in<bool> case_insensitive_, cpp2::impl::in<bool> reverse_, cpp2::impl::in<std::string> str);
 
-#line 7602 "reflect.h2"
+#line 7774 "reflect.h2"
     public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr;
 
-#line 7703 "reflect.h2"
+#line 7875 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
 
-#line 7707 "reflect.h2"
+#line 7879 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
     public: virtual ~group_ref_token() noexcept;
 
@@ -2977,10 +2980,10 @@ class group_ref_token
     public: auto operator=(group_ref_token const&) -> void = delete;
 
 
-#line 7710 "reflect.h2"
+#line 7882 "reflect.h2"
 };
 
-#line 7713 "reflect.h2"
+#line 7885 "reflect.h2"
 //  Regex syntax: (<tokens>)      Example: (abc)
 //                (?<modifiers)            (?i)
 //                (?<modifiers>:<tokens>)  (?i:abc)
@@ -2994,29 +2997,29 @@ class group_ref_token
 class group_token
 : public regex_token {
 
-#line 7727 "reflect.h2"
+#line 7899 "reflect.h2"
     private: int number {-1}; 
     private: bool reverse_eval {false}; 
     private: token_ptr inner {nullptr}; 
 
     public: [[nodiscard]] static auto parse_lookahead_lookbehind(parse_context& ctx, cpp2::impl::in<std::string> syntax, cpp2::impl::in<bool> lookahead, cpp2::impl::in<bool> positive) -> token_ptr;
 
-#line 7749 "reflect.h2"
+#line 7921 "reflect.h2"
     public: [[nodiscard]] static auto parse_atomic_pattern(parse_context& ctx, cpp2::impl::in<std::string> syntax) -> token_ptr;
 
-#line 7763 "reflect.h2"
+#line 7935 "reflect.h2"
     public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr;
 
-#line 7922 "reflect.h2"
+#line 8094 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
 
-#line 7930 "reflect.h2"
+#line 8102 "reflect.h2"
     public: [[nodiscard]] static auto gen_string(cpp2::impl::in<std::string> name, cpp2::impl::in<bool> name_brackets, cpp2::impl::in<bool> has_modifier, cpp2::impl::in<std::string> modifiers, cpp2::impl::in<token_ptr> inner_) -> std::string;
 
-#line 7948 "reflect.h2"
+#line 8120 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 7979 "reflect.h2"
+#line 8151 "reflect.h2"
     public: auto add_groups(std::set<int>& groups) const -> void override;
     public: virtual ~group_token() noexcept;
 
@@ -3025,25 +3028,25 @@ class group_token
     public: auto operator=(group_token const&) -> void = delete;
 
 
-#line 7986 "reflect.h2"
+#line 8158 "reflect.h2"
 };
 
-#line 7989 "reflect.h2"
+#line 8161 "reflect.h2"
 //  Regex syntax: \x<number> or \x{<number>}  Example: \x{62}
 //
 [[nodiscard]] auto hexadecimal_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 8030 "reflect.h2"
+#line 8202 "reflect.h2"
 //  Regex syntax: $  Example: aa$
 //
 [[nodiscard]] auto line_end_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 8050 "reflect.h2"
+#line 8222 "reflect.h2"
 //  Regex syntax: ^  Example: ^aa
 //
 [[nodiscard]] auto line_start_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 8066 "reflect.h2"
+#line 8238 "reflect.h2"
 //  Regex syntax: (?=) or (?!) or (*pla), etc.  Example: (?=AA)
 //
 //  Parsed in group_token.
@@ -3051,20 +3054,20 @@ class group_token
 class lookahead_lookbehind_token
 : public regex_token {
 
-#line 8074 "reflect.h2"
+#line 8246 "reflect.h2"
     protected: bool lookahead; 
     protected: bool positive; 
     public:   token_ptr inner {nullptr}; 
 
     public: lookahead_lookbehind_token(cpp2::impl::in<bool> lookahead_, cpp2::impl::in<bool> positive_);
 
-#line 8083 "reflect.h2"
+#line 8255 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 8094 "reflect.h2"
+#line 8266 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
 
-#line 8101 "reflect.h2"
+#line 8273 "reflect.h2"
     public: auto add_groups(std::set<int>& groups) const -> void override;
     public: virtual ~lookahead_lookbehind_token() noexcept;
 
@@ -3072,26 +3075,26 @@ class lookahead_lookbehind_token
     public: auto operator=(lookahead_lookbehind_token const&) -> void = delete;
 
 
-#line 8104 "reflect.h2"
+#line 8276 "reflect.h2"
 };
 
-#line 8107 "reflect.h2"
+#line 8279 "reflect.h2"
 // Named character classes
 //
 [[nodiscard]] auto named_class_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 8135 "reflect.h2"
+#line 8307 "reflect.h2"
 //  Regex syntax: \o{<number>}  Example: \o{142}
 //
 [[nodiscard]] auto octal_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 8163 "reflect.h2"
+#line 8335 "reflect.h2"
 //  Regex syntax: <matcher>{min, max}  Example: a{2,4}
 //
 class range_token
 : public regex_token {
 
-#line 8169 "reflect.h2"
+#line 8341 "reflect.h2"
               protected: int min_count {-1}; 
               protected: int max_count {-1}; 
               protected: int kind {range_flags::greedy}; 
@@ -3101,22 +3104,22 @@ class range_token
 
     public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr;
 
-#line 8249 "reflect.h2"
+#line 8421 "reflect.h2"
     public: auto parse_modifier(parse_context& ctx) & -> void;
 
-#line 8261 "reflect.h2"
+#line 8433 "reflect.h2"
     public: [[nodiscard]] auto gen_mod_string() const& -> std::string;
 
-#line 8274 "reflect.h2"
+#line 8446 "reflect.h2"
     public: [[nodiscard]] auto gen_range_string() const& -> std::string;
 
-#line 8293 "reflect.h2"
+#line 8465 "reflect.h2"
     public: [[nodiscard]] auto reverse() const -> token_ptr override;
 
-#line 8303 "reflect.h2"
+#line 8475 "reflect.h2"
     public: auto generate_code(generation_context& ctx) const -> void override;
 
-#line 8314 "reflect.h2"
+#line 8486 "reflect.h2"
     public: auto add_groups(std::set<int>& groups) const -> void override;
     public: virtual ~range_token() noexcept;
 
@@ -3124,16 +3127,16 @@ class range_token
     public: auto operator=(range_token const&) -> void = delete;
 
 
-#line 8317 "reflect.h2"
+#line 8489 "reflect.h2"
 };
 
-#line 8320 "reflect.h2"
+#line 8492 "reflect.h2"
 //  Regex syntax: *, +, or ?  Example: aa*
 //
 class special_range_token
 : public range_token {
 
-#line 8326 "reflect.h2"
+#line 8498 "reflect.h2"
     public: [[nodiscard]] static auto parse(parse_context& ctx) -> token_ptr;
     public: virtual ~special_range_token() noexcept;
 
@@ -3142,7 +3145,7 @@ class special_range_token
     public: auto operator=(special_range_token const&) -> void = delete;
 
 
-#line 8356 "reflect.h2"
+#line 8528 "reflect.h2"
 };
 
 //  Regex syntax: \G  Example: \Gaa
@@ -3151,14 +3154,14 @@ class special_range_token
 //
 [[nodiscard]] auto start_match_parse(parse_context& ctx) -> token_ptr;
 
-#line 8378 "reflect.h2"
+#line 8550 "reflect.h2"
 //  Regex syntax: \b or \B  Example: \bword\b
 //
 //  Matches the start end end of word boundaries.
 //
 [[nodiscard]] auto word_boundary_token_parse(parse_context& ctx) -> token_ptr;
 
-#line 8400 "reflect.h2"
+#line 8572 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  Parser for regular expression.
@@ -3179,24 +3182,24 @@ template<typename Error_out> class regex_generator
 
     public: regex_generator(cpp2::impl::in<std::string_view> r, Error_out const& e);
 
-#line 8423 "reflect.h2"
+#line 8595 "reflect.h2"
     public: [[nodiscard]] auto parse() & -> std::string;
 
-#line 8458 "reflect.h2"
+#line 8630 "reflect.h2"
     private: auto extract_modifiers() & -> void;
     public: regex_generator(regex_generator const&) = delete; /* No 'that' constructor, suppress copy */
     public: auto operator=(regex_generator const&) -> void = delete;
 
 
-#line 8472 "reflect.h2"
+#line 8644 "reflect.h2"
 };
 
 template<typename Err> [[nodiscard]] auto generate_regex(cpp2::impl::in<std::string_view> regex, Err const& err) -> std::string;
 
-#line 8484 "reflect.h2"
+#line 8656 "reflect.h2"
 auto regex_gen(meta::type_declaration& t) -> void;
 
-#line 8539 "reflect.h2"
+#line 8711 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  apply_metafunctions
@@ -3207,7 +3210,7 @@ auto regex_gen(meta::type_declaration& t) -> void;
     auto const& error
     ) -> bool;
 
-#line 8671 "reflect.h2"
+#line 8846 "reflect.h2"
 }
 
 }
@@ -5469,12 +5472,185 @@ auto hashable(meta::type_declaration& t) -> void
 #line 1789 "reflect.h2"
 //-----------------------------------------------------------------------
 //
+//  euclidean_vector
+//  (a little metafunction experiment)
+//
+//  Automatically generate +, -, * and / operators across all member variables, optionally with
+//  a single numeric type argument (eg. vector3 * float) if given a template argument. 
+//
+//  Additionally creates functions For getting the magnitude/length, normalisation, dot product.
+//
+#line 1799 "reflect.h2"
+auto euclidean_vector(meta::type_declaration& t) -> void
+{
+    auto single_arg_type {CPP2_UFCS(get_argument)(t, 0)}; 
+    bool add_single_arg_fns {CPP2_UFCS(size)(single_arg_type) != 0}; 
+
+    std::string op_add {"operator+: (this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+    std::string op_sub {"operator-: (this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+    std::string op_mul {"operator*: (this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+    std::string op_div {"operator/: (this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+
+    std::string op_negate {"operator-: (this) -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+
+    std::string op_assign_add {"operator+=: (inout this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") = { "}; 
+    std::string op_assign_sub {"operator-=: (inout this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") = { "}; 
+    std::string op_assign_mul {"operator*=: (inout this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") = { "}; 
+    std::string op_assign_div {"operator/=: (inout this, in_ref other: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") = { "}; 
+
+    std::string op_add_sc {"operator+: (this, other: " + cpp2::to_string(single_arg_type) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+    std::string op_sub_sc {"operator-: (this, other: " + cpp2::to_string(single_arg_type) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+    std::string op_mul_sc {"operator*: (this, other: " + cpp2::to_string(single_arg_type) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+    std::string op_div_sc {"operator/: (this, other: " + cpp2::to_string(single_arg_type) + ") -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = " + cpp2::to_string(CPP2_UFCS(name)(t)) + "( "}; 
+
+    std::string op_assign_add_sc {"operator+=: (inout this, other: " + cpp2::to_string(single_arg_type) + ") = { "}; 
+    std::string op_assign_sub_sc {"operator-=: (inout this, other: " + cpp2::to_string(single_arg_type) + ") = { "}; 
+    std::string op_assign_mul_sc {"operator*=: (inout this, other: " + cpp2::to_string(single_arg_type) + ") = { "}; 
+    std::string op_assign_div_sc {"operator/=: (inout this, other: " + cpp2::to_string(cpp2::move(single_arg_type)) + ") = { "}; 
+
+    std::string fn_lengthSq {"lengthSquared: (this) -> _ = "}; 
+
+    std::string fn_normalise {"normalise: (inout this) = {\n    len: _ = length();\n"}; 
+    std::string fn_normalised {"normalised: (this) -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = {\n    len: _ = length();\n    return " + cpp2::to_string(CPP2_UFCS(name)(t)) + "(\n"}; 
+
+    std::string fn_dot {"dot: (in_ref lhs: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ", in_ref rhs: " + cpp2::to_string(CPP2_UFCS(name)(t)) + ") -> _ = "}; 
+
+    bool after_first_value_added {false}; 
+    for ( 
+          auto const& o : CPP2_UFCS(get_member_objects)(t) ) 
+    {
+        if (after_first_value_added) {
+            op_add += ", ";
+            op_sub += ", ";
+            op_mul += ", ";
+            op_div += ", ";
+
+            op_negate += ", ";
+
+            if (add_single_arg_fns) {
+                op_add_sc += ", ";
+                op_sub_sc += ", ";
+                op_mul_sc += ", ";
+                op_div_sc += ", ";
+            }
+
+            fn_lengthSq += " + ";
+            fn_dot += " + ";
+
+            fn_normalised += ",\n";
+        }else {
+            fn_normalised += "\n";
+        }
+
+        op_add += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " + other." + cpp2::to_string(CPP2_UFCS(name)(o)) + "";
+        op_sub += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " - other." + cpp2::to_string(CPP2_UFCS(name)(o)) + "";
+        op_mul += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " * other." + cpp2::to_string(CPP2_UFCS(name)(o)) + "";
+        op_div += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " / other." + cpp2::to_string(CPP2_UFCS(name)(o)) + "";
+
+        op_negate += "-" + cpp2::to_string(CPP2_UFCS(name)(o)) + "";
+
+        fn_normalise += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " /= len;\n";
+        fn_normalised += "    " + cpp2::to_string(CPP2_UFCS(name)(o)) + " / len";
+
+        if (add_single_arg_fns) {
+            op_add_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " + other";
+            op_sub_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " - other";
+            op_mul_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " * other";
+            op_div_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " / other";
+        }
+
+        op_assign_add += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " += other." + cpp2::to_string(CPP2_UFCS(name)(o)) + ";";
+        op_assign_sub += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " -= other." + cpp2::to_string(CPP2_UFCS(name)(o)) + ";";
+        op_assign_mul += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " *= other." + cpp2::to_string(CPP2_UFCS(name)(o)) + ";";
+        op_assign_div += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " /= other." + cpp2::to_string(CPP2_UFCS(name)(o)) + ";";
+
+        if (add_single_arg_fns) {
+            op_assign_add_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " += other;";
+            op_assign_sub_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " -= other;";
+            op_assign_mul_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " *= other;";
+            op_assign_div_sc += "" + cpp2::to_string(CPP2_UFCS(name)(o)) + " /= other;";
+        }
+
+        fn_lengthSq += "( " + cpp2::to_string(CPP2_UFCS(name)(o)) + " * " + cpp2::to_string(CPP2_UFCS(name)(o)) + " )";
+        fn_dot += "( lhs." + cpp2::to_string(CPP2_UFCS(name)(o)) + " * rhs." + cpp2::to_string(CPP2_UFCS(name)(o)) + " )";
+
+        after_first_value_added = true;
+    }
+
+    op_assign_add += " }";
+    op_assign_sub += " }";
+    op_assign_mul += " }";
+    op_assign_div += " }";
+
+    if (add_single_arg_fns) {
+        op_assign_add_sc += " }";
+        op_assign_sub_sc += " }";
+        op_assign_mul_sc += " }";
+        op_assign_div_sc += " }";
+    }
+
+    op_add += " );";
+    op_sub += " );";
+    op_mul += " );";
+    op_div += " );";
+
+    op_negate += " );";
+
+    if (add_single_arg_fns) {
+        op_add_sc += " );";
+        op_sub_sc += " );";
+        op_mul_sc += " );";
+        op_div_sc += " );";
+    }
+
+    fn_lengthSq += ";";
+    fn_dot += ";";
+
+    fn_normalise += "}";
+    fn_normalised += ");\n}";
+
+    CPP2_UFCS(add_member)(t, cpp2::move(fn_lengthSq));
+    CPP2_UFCS(add_member)(t, "length: (this) -> _ = std::sqrt( lengthSquared() );");
+
+    CPP2_UFCS(add_member)(t, cpp2::move(fn_normalise));
+    CPP2_UFCS(add_member)(t, cpp2::move(fn_normalised));
+
+    CPP2_UFCS(add_member)(t, cpp2::move(fn_dot));
+
+    CPP2_UFCS(add_member)(t, cpp2::move(op_add));
+    CPP2_UFCS(add_member)(t, cpp2::move(op_sub));
+    CPP2_UFCS(add_member)(t, cpp2::move(op_mul));
+    CPP2_UFCS(add_member)(t, cpp2::move(op_div));
+
+    CPP2_UFCS(add_member)(t, cpp2::move(op_negate));
+
+    CPP2_UFCS(add_member)(t, cpp2::move(op_assign_add));
+    CPP2_UFCS(add_member)(t, cpp2::move(op_assign_sub));
+    CPP2_UFCS(add_member)(t, cpp2::move(op_assign_mul));
+    CPP2_UFCS(add_member)(t, cpp2::move(op_assign_div));
+
+    if (cpp2::move(add_single_arg_fns)) {
+        CPP2_UFCS(add_member)(t, cpp2::move(op_add_sc));
+        CPP2_UFCS(add_member)(t, cpp2::move(op_sub_sc));
+        CPP2_UFCS(add_member)(t, cpp2::move(op_mul_sc));
+        CPP2_UFCS(add_member)(t, cpp2::move(op_div_sc));
+
+        CPP2_UFCS(add_member)(t, cpp2::move(op_assign_add_sc));
+        CPP2_UFCS(add_member)(t, cpp2::move(op_assign_sub_sc));
+        CPP2_UFCS(add_member)(t, cpp2::move(op_assign_mul_sc));
+        CPP2_UFCS(add_member)(t, cpp2::move(op_assign_div_sc));
+    }
+}
+
+#line 1961 "reflect.h2"
+//-----------------------------------------------------------------------
+//
 //  basic_value
 //
 //  A regular type: copyable, plus has public default construction
 //  and no protected or virtual functions
 //
-#line 1796 "reflect.h2"
+#line 1968 "reflect.h2"
 auto basic_value(meta::type_declaration& t) -> void
 {
     CPP2_UFCS(copyable)(t);
@@ -5503,28 +5679,28 @@ auto basic_value(meta::type_declaration& t) -> void
 //
 //  Note: the ordering that should be encouraged as default gets the nice name
 //
-#line 1824 "reflect.h2"
+#line 1996 "reflect.h2"
 auto value(meta::type_declaration& t) -> void
 {
     CPP2_UFCS(ordered)(t);
     CPP2_UFCS(basic_value)(t);
 }
 
-#line 1830 "reflect.h2"
+#line 2002 "reflect.h2"
 auto weakly_ordered_value(meta::type_declaration& t) -> void
 {
     CPP2_UFCS(weakly_ordered)(t);
     CPP2_UFCS(basic_value)(t);
 }
 
-#line 1836 "reflect.h2"
+#line 2008 "reflect.h2"
 auto partially_ordered_value(meta::type_declaration& t) -> void
 {
     CPP2_UFCS(partially_ordered)(t);
     CPP2_UFCS(basic_value)(t);
 }
 
-#line 1843 "reflect.h2"
+#line 2015 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //     C.20: If you can avoid defining default operations, do
@@ -5547,7 +5723,7 @@ auto partially_ordered_value(meta::type_declaration& t) -> void
 //
 //  a type without declared copy/move/destructor functions
 //
-#line 1865 "reflect.h2"
+#line 2037 "reflect.h2"
 auto cpp1_rule_of_zero(meta::type_declaration& t) -> void
 {
     for ( auto& mf : CPP2_UFCS(get_member_functions)(t) ) 
@@ -5590,7 +5766,7 @@ auto cpp1_rule_of_zero(meta::type_declaration& t) -> void
 //  parameters instead of concrete forwarding parameters (mainly used
 //  for cppfront internal use, so cppfront builds under GCC 10)
 //
-#line 1907 "reflect.h2"
+#line 2079 "reflect.h2"
 auto cpp2_struct(meta::type_declaration& t) -> void
 {
     std::string ctor_params {}; 
@@ -5647,7 +5823,7 @@ value_member_info::value_member_info(auto const& name_, auto const& type_, auto
                                                                , type{ type_ }
                                                                , value{ value_ }{}
 
-#line 1959 "reflect.h2"
+#line 2131 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //     "C enumerations constitute a curiously half-baked concept. ...
@@ -5666,7 +5842,7 @@ value_member_info::value_member_info(auto const& name_, auto const& type_, auto
 //  a type together with named constants that are its possible values
 //
 
-#line 1982 "reflect.h2"
+#line 2154 "reflect.h2"
 auto basic_enum(
     meta::type_declaration& t, 
     auto const& nextval, 
@@ -5691,7 +5867,7 @@ auto basic_enum(
 {
 std::string value{"-1"};
 
-#line 2005 "reflect.h2"
+#line 2177 "reflect.h2"
     for ( 
           auto const& m : CPP2_UFCS(get_members)(t) ) 
     if (  CPP2_UFCS(is_member_object)(m)) 
@@ -5733,7 +5909,7 @@ std::string value{"-1"};
     }
 }
 
-#line 2045 "reflect.h2"
+#line 2217 "reflect.h2"
     if ((CPP2_UFCS(empty)(enumerators))) {
         CPP2_UFCS(error)(t, "an enumeration must contain at least one enumerator value");
         return ; 
@@ -5784,7 +5960,7 @@ std::string value{"-1"};
         }
     }
 
-#line 2096 "reflect.h2"
+#line 2268 "reflect.h2"
     //  2. Replace: Erase the contents and replace with modified contents
     //
     //  Note that most values and functions are declared as '==' compile-time values, i.e. Cpp1 'constexpr'
@@ -5834,7 +6010,7 @@ std::string to_string_impl{"    to_string_impl: (this, prefix: std::string_view"
     //  Provide 'to_string' and 'to_code' functions to print enumerator
     //  name(s) as human-readable strings or as code expressions
 
-#line 2143 "reflect.h2"
+#line 2315 "reflect.h2"
     {
         if (bitwise) {
             to_string_impl += ", separator: std::string_view ) -> std::string = { \n"
@@ -5875,7 +6051,7 @@ std::string to_string_impl{"    to_string_impl: (this, prefix: std::string_view"
     }
 }
 
-#line 2182 "reflect.h2"
+#line 2354 "reflect.h2"
     if (bitwise) {
         CPP2_UFCS(add_member)(t, "    to_string: (this) -> std::string = to_string_impl( \"\", \", \" );");
         CPP2_UFCS(add_member)(t, "    to_code  : (this) -> std::string = to_string_impl( \"" + cpp2::to_string(CPP2_UFCS(name)(t)) + "::\", \" | \" );");
@@ -5889,7 +6065,7 @@ std::string from_string{"    from_string: (s: std::string_view) -> " + cpp2::to_
 
     //  Provide a 'from_string' function to parse strings into enumerators    
 
-#line 2193 "reflect.h2"
+#line 2365 "reflect.h2"
     {
         std::string_view prefix {""}; 
         std::string_view combine_op {"return"}; 
@@ -5911,7 +6087,7 @@ std::string from_string{"    from_string: (s: std::string_view) -> " + cpp2::to_
 {
 std::string_view else_{""};
 
-#line 2213 "reflect.h2"
+#line 2385 "reflect.h2"
         for ( 
               auto const& e : cpp2::move(enumerators) ) {
             from_string += "            " + cpp2::to_string(else_) + "if \"" + cpp2::to_string(e.name) + "\" == x { " + cpp2::to_string(combine_op) + " " + cpp2::to_string(CPP2_UFCS(name)(t)) + "::" + cpp2::to_string(e.name) + "; }\n";
@@ -5919,7 +6095,7 @@ std::string_view else_{""};
         }
 }
 
-#line 2219 "reflect.h2"
+#line 2391 "reflect.h2"
         if (bitwise) {
             from_string += "            else { break outer; }\n"
                            "        }\n"
@@ -5935,11 +6111,11 @@ std::string_view else_{""};
     }
 }
 
-#line 2233 "reflect.h2"
+#line 2405 "reflect.h2"
     CPP2_UFCS(add_member)(t, "    from_code: (s: std::string_view) -> " + cpp2::to_string(CPP2_UFCS(name)(t)) + " = { str: std::string = s; return from_string( cpp2::string_util::replace_all(str, \"" + cpp2::to_string(CPP2_UFCS(name)(t)) + "::\", \"\" ) ); }");
 }
 
-#line 2237 "reflect.h2"
+#line 2409 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //    "An enum[...] is a totally ordered value type that stores a
@@ -5949,7 +6125,7 @@ std::string_view else_{""};
 //
 //          -- P0707R4, section 3
 //
-#line 2246 "reflect.h2"
+#line 2418 "reflect.h2"
 auto cpp2_enum(meta::type_declaration& t) -> void
 {
     //  Let basic_enum do its thing, with an incrementing value generator
@@ -5966,7 +6142,7 @@ auto cpp2_enum(meta::type_declaration& t) -> void
     );
 }
 
-#line 2263 "reflect.h2"
+#line 2435 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //     "flag_enum expresses an enumeration that stores values
@@ -5977,7 +6153,7 @@ auto cpp2_enum(meta::type_declaration& t) -> void
 //
 //          -- P0707R4, section 3
 //
-#line 2273 "reflect.h2"
+#line 2445 "reflect.h2"
 auto flag_enum(meta::type_declaration& t) -> void
 {
     //  Let basic_enum do its thing, with a power-of-two value generator
@@ -5999,7 +6175,7 @@ auto flag_enum(meta::type_declaration& t) -> void
     );
 }
 
-#line 2295 "reflect.h2"
+#line 2467 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //     "As with void*, programmers should know that unions [...] are
@@ -6024,7 +6200,7 @@ auto flag_enum(meta::type_declaration& t) -> void
 //  a type that contains exactly one of a fixed set of values at a time
 //
 
-#line 2319 "reflect.h2"
+#line 2491 "reflect.h2"
 auto cpp2_union(meta::type_declaration& t) -> void
 {
     std::vector<value_member_info> alternatives {}; 
@@ -6033,7 +6209,7 @@ auto value{0};
 
     //  1. Gather: All the user-written members, and find/compute the max size
 
-#line 2326 "reflect.h2"
+#line 2498 "reflect.h2"
     for ( 
 
            auto const& m : CPP2_UFCS(get_members)(t) )  { do 
@@ -6063,7 +6239,7 @@ auto value{0};
     } while (false); ++value; }
 }
 
-#line 2354 "reflect.h2"
+#line 2526 "reflect.h2"
     std::string discriminator_type {}; 
     if (cpp2::impl::cmp_less(CPP2_UFCS(ssize)(alternatives),std::numeric_limits<cpp2::i8>::max())) {
         discriminator_type = "i8";
@@ -6078,7 +6254,7 @@ auto value{0};
         discriminator_type = "i64";
     }}}
 
-#line 2369 "reflect.h2"
+#line 2541 "reflect.h2"
     //  2. Replace: Erase the contents and replace with modified contents
 
     CPP2_UFCS(remove_marked_members)(t);
@@ -6087,7 +6263,7 @@ std::string storage{"    _storage: cpp2::aligned_storage<cpp2::max( "};
 
     //  Provide storage
 
-#line 2375 "reflect.h2"
+#line 2547 "reflect.h2"
     {
         for ( 
               auto const& e : alternatives ) {
@@ -6107,7 +6283,7 @@ std::string storage{"    _storage: cpp2::aligned_storage<cpp2::max( "};
 }
 
     //  Provide discriminator
-#line 2393 "reflect.h2"
+#line 2565 "reflect.h2"
     CPP2_UFCS(add_member)(t, "    _discriminator: " + cpp2::to_string(cpp2::move(discriminator_type)) + " = -1;\n");
 
     //  Add the alternatives: is_alternative, get_alternative, and set_alternative
@@ -6143,7 +6319,7 @@ std::string destroy{"    private _destroy: (inout this) = {\n"};
 
     //  Add destroy
 
-#line 2426 "reflect.h2"
+#line 2598 "reflect.h2"
     {
         for ( 
               auto const& a : alternatives ) {
@@ -6157,7 +6333,7 @@ std::string destroy{"    private _destroy: (inout this) = {\n"};
 }
 
     //  Add the destructor
-#line 2438 "reflect.h2"
+#line 2610 "reflect.h2"
     CPP2_UFCS(add_member)(t, "    operator=: (move this) = { _destroy(); _ = this; }");
 
     //  Add default constructor
@@ -6167,7 +6343,7 @@ std::string value_set{""};
 
     //  Add copy/move construction and assignment
 
-#line 2445 "reflect.h2"
+#line 2617 "reflect.h2"
     {
         for ( 
               auto const& a : cpp2::move(alternatives) ) {
@@ -6187,27 +6363,27 @@ std::string value_set{""};
                     );
     }
 }
-#line 2463 "reflect.h2"
+#line 2635 "reflect.h2"
 }
 
-#line 2466 "reflect.h2"
+#line 2638 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  print - output a pretty-printed visualization of t
 //
-#line 2470 "reflect.h2"
+#line 2642 "reflect.h2"
 auto print(cpp2::impl::in<meta::type_declaration> t) -> void
 {
     std::cout << CPP2_UFCS(print)(t) << "\n";
 }
 
-#line 2476 "reflect.h2"
+#line 2648 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  noisy - make each function print its name and signature,
 //          so the programmer can see what's called
 //
-#line 2481 "reflect.h2"
+#line 2653 "reflect.h2"
 auto noisy(cpp2::impl::in<meta::type_declaration> t) -> void
 {
     for ( 
@@ -6224,7 +6400,7 @@ auto noisy(cpp2::impl::in<meta::type_declaration> t) -> void
     }
 }
 
-#line 2498 "reflect.h2"
+#line 2670 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  python - expose the type using pybind11
@@ -6232,14 +6408,14 @@ auto noisy(cpp2::impl::in<meta::type_declaration> t) -> void
 //  *** Basic proof of concept only, limited and not well tested
 //      Hardcoded for pybind11 and g++10 and my local cppfront include path
 //
-#line 2505 "reflect.h2"
+#line 2677 "reflect.h2"
 [[nodiscard]] auto python_param_names_and_types(cpp2::impl::in<meta::function_declaration> mf) -> python_param_names_and_types_ret
 
-#line 2511 "reflect.h2"
+#line 2683 "reflect.h2"
 {
     std::string names {};
     std::string types {};
-#line 2512 "reflect.h2"
+#line 2684 "reflect.h2"
     for ( 
          auto const& param : CPP2_UFCS(get_parameters)(mf) ) 
     if ( CPP2_UFCS(name)(CPP2_UFCS(get_declaration)(param)) != "this") 
@@ -6255,7 +6431,7 @@ auto noisy(cpp2::impl::in<meta::type_declaration> t) -> void
     static_cast<void>(names);
 return  { std::move(names), std::move(types) }; }
 
-#line 2527 "reflect.h2"
+#line 2699 "reflect.h2"
 auto python(meta::type_declaration& t) -> void
 {
     std::string bind {}; 
@@ -6292,14 +6468,14 @@ auto python(meta::type_declaration& t) -> void
     CPP2_UFCS(add_extra_build_step)(t, cpp2::move(build));
 }
 
-#line 2564 "reflect.h2"
+#line 2736 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  javascript - expose the type using emscripten
 // 
 //  *** Basic proof of concept only, limited and not well tested
 //
-#line 2570 "reflect.h2"
+#line 2742 "reflect.h2"
 auto javascript(meta::type_declaration& t) -> void
 {
     std::string bind {}; 
@@ -6336,12 +6512,12 @@ auto javascript(meta::type_declaration& t) -> void
     CPP2_UFCS(disable_ref_qualifier_generation)(t);
 }
 
-#line 2607 "reflect.h2"
+#line 2779 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  For reflection test cases
 //
-#line 2611 "reflect.h2"
+#line 2783 "reflect.h2"
 auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     std::cout 
@@ -6350,12 +6526,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         << "\n";
 }
 
-#line 2621 "reflect.h2"
+#line 2793 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::declaration> decl) -> void{
         traverse(decl);
     }
 
-#line 2625 "reflect.h2"
+#line 2797 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::declaration> decl) -> void
     {
         if (CPP2_UFCS(is_function)(decl)) {
@@ -6375,12 +6551,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         // ...
     }
 
-#line 2645 "reflect.h2"
+#line 2817 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::function_declaration> f) -> void{
         traverse(f);
     }
 
-#line 2649 "reflect.h2"
+#line 2821 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::function_declaration> f) -> void
     {
         auto parameters {CPP2_UFCS(get_parameters)(f)}; 
@@ -6401,12 +6577,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2670 "reflect.h2"
+#line 2842 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::object_declaration> o) -> void{
         traverse(o);
     }
 
-#line 2674 "reflect.h2"
+#line 2846 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::object_declaration> o) -> void
     {
         if (CPP2_UFCS(has_initializer)(o)) {
@@ -6414,12 +6590,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2682 "reflect.h2"
+#line 2854 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::type_declaration> t) -> void{
         traverse(t);
     }
 
-#line 2686 "reflect.h2"
+#line 2858 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::type_declaration> t) -> void
     {
         for ( auto const& m : CPP2_UFCS(get_members)(t) ) {
@@ -6427,23 +6603,23 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2694 "reflect.h2"
+#line 2866 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void{
         traverse(t);
     }
 
-#line 2698 "reflect.h2"
+#line 2870 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void
     {
         pre_traverse(CPP2_UFCS(get_declaration)(t));
     }
 
-#line 2703 "reflect.h2"
+#line 2875 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::statement> stmt) -> void{
         traverse(stmt);
     }
 
-#line 2707 "reflect.h2"
+#line 2879 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::statement> stmt) -> void
     {
         if (CPP2_UFCS(is_expression_statement)(stmt)) {
@@ -6478,12 +6654,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         //  jump
     }
 
-#line 2742 "reflect.h2"
+#line 2914 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::compound_statement> stmt) -> void{
         traverse(stmt);
     }
 
-#line 2746 "reflect.h2"
+#line 2918 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::compound_statement> stmt) -> void
     {
         auto stmts {CPP2_UFCS(get_statements)(stmt)}; 
@@ -6493,12 +6669,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2756 "reflect.h2"
+#line 2928 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::return_statement> stmt) -> void{
         traverse(stmt);
     }
 
-#line 2760 "reflect.h2"
+#line 2932 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::return_statement> stmt) -> void
     {
         if (CPP2_UFCS(has_expression)(stmt)) {
@@ -6506,12 +6682,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2768 "reflect.h2"
+#line 2940 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::iteration_statement> stmt) -> void{
         traverse(stmt);
     }
 
-#line 2772 "reflect.h2"
+#line 2944 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::iteration_statement> stmt) -> void
     {
         if (CPP2_UFCS(is_do)(stmt) || CPP2_UFCS(is_while)(stmt)) {
@@ -6530,12 +6706,12 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2791 "reflect.h2"
+#line 2963 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::selection_statement> stmt) -> void{
         traverse(stmt);
     }
 
-#line 2795 "reflect.h2"
+#line 2967 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::selection_statement> stmt) -> void
     {
         pre_traverse(CPP2_UFCS(get_expression)(stmt));
@@ -6546,14 +6722,14 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2806 "reflect.h2"
+#line 2978 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::expression> expr) -> void
     {
         // Nothing to select here.
         traverse(expr);
     }
 
-#line 2812 "reflect.h2"
+#line 2984 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::expression> expr) -> void
     {
         //  An expression has other shortcuts to query deeper properties,
@@ -6567,7 +6743,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         pre_traverse(CPP2_UFCS(as_assignment_expression)(expr));
     }
 
-#line 2826 "reflect.h2"
+#line 2998 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6585,7 +6761,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2843 "reflect.h2"
+#line 3015 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6597,7 +6773,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2854 "reflect.h2"
+#line 3026 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6615,7 +6791,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2871 "reflect.h2"
+#line 3043 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6627,7 +6803,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2883 "reflect.h2"
+#line 3055 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6645,7 +6821,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2900 "reflect.h2"
+#line 3072 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6657,7 +6833,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2911 "reflect.h2"
+#line 3083 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6675,7 +6851,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2928 "reflect.h2"
+#line 3100 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6687,7 +6863,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2939 "reflect.h2"
+#line 3111 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6705,7 +6881,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2956 "reflect.h2"
+#line 3128 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6717,7 +6893,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2968 "reflect.h2"
+#line 3140 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6735,7 +6911,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2985 "reflect.h2"
+#line 3157 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6747,7 +6923,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 2997 "reflect.h2"
+#line 3169 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6765,7 +6941,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3014 "reflect.h2"
+#line 3186 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6777,7 +6953,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3025 "reflect.h2"
+#line 3197 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6795,7 +6971,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3042 "reflect.h2"
+#line 3214 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6807,7 +6983,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3053 "reflect.h2"
+#line 3225 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6825,7 +7001,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3070 "reflect.h2"
+#line 3242 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6837,7 +7013,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3081 "reflect.h2"
+#line 3253 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6855,7 +7031,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3098 "reflect.h2"
+#line 3270 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6867,7 +7043,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3109 "reflect.h2"
+#line 3281 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6885,7 +7061,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3126 "reflect.h2"
+#line 3298 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6897,7 +7073,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3138 "reflect.h2"
+#line 3310 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6915,7 +7091,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3155 "reflect.h2"
+#line 3327 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -6927,7 +7103,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3166 "reflect.h2"
+#line 3338 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(isas)}; 
@@ -6944,7 +7120,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3182 "reflect.h2"
+#line 3354 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(isas)}; 
@@ -6956,7 +7132,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3193 "reflect.h2"
+#line 3365 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::expression_list> exprs) -> void
     {
         for ( auto const& expr : CPP2_UFCS(get_expressions)(exprs) ) {
@@ -6964,7 +7140,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3200 "reflect.h2"
+#line 3372 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void
     {
         auto ops {CPP2_UFCS(get_ops)(prefix)}; 
@@ -6981,13 +7157,13 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3216 "reflect.h2"
+#line 3388 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void
     {
         pre_traverse(CPP2_UFCS(get_postfix_expression)(prefix));
     }
 
-#line 3221 "reflect.h2"
+#line 3393 "reflect.h2"
     auto simple_traverser::pre_traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(postfix)}; 
@@ -7004,7 +7180,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3237 "reflect.h2"
+#line 3409 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(postfix)}; 
@@ -7024,13 +7200,13 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3256 "reflect.h2"
+#line 3428 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::unqualified_id> uid) -> void
     {
         static_cast<void>(uid);
     }
 
-#line 3262 "reflect.h2"
+#line 3434 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::qualified_id> qid) -> void
     {
         for ( 
@@ -7040,7 +7216,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }
     }
 
-#line 3272 "reflect.h2"
+#line 3444 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::type_id> tid) -> void
     {
         if (CPP2_UFCS(is_postfix_expression)(tid)) {
@@ -7057,7 +7233,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }}}
     }
 
-#line 3289 "reflect.h2"
+#line 3461 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::primary_expression> primary) -> void
     {
         if (CPP2_UFCS(is_identifier)(primary)) {
@@ -7077,7 +7253,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }}}}
     }
 
-#line 3309 "reflect.h2"
+#line 3481 "reflect.h2"
     auto simple_traverser::traverse(cpp2::impl::in<meta::id_expression> idexpr) -> void
     {
         if (CPP2_UFCS(is_identifier)(idexpr)) {
@@ -7094,7 +7270,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
         }}}
     }
 
-#line 3327 "reflect.h2"
+#line 3499 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  sample_traverser serves two purposes:
@@ -7105,7 +7281,7 @@ auto sample_print(cpp2::impl::in<std::string_view> s, cpp2::impl::in<cpp2::i32>
 //        for reflecting on function bodies (statements, expressions)
 //
 
-#line 3337 "reflect.h2"
+#line 3509 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::declaration> decl, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     sample_print("Declaration: " + cpp2::to_string(CPP2_UFCS(name)(decl)) + "", indent);
@@ -7127,7 +7303,7 @@ auto sample_traverser(cpp2::impl::in<meta::declaration> decl, cpp2::impl::in<cpp
     // ...
 }
 
-#line 3359 "reflect.h2"
+#line 3531 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::function_declaration> f, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     sample_print("Function: " + cpp2::to_string(CPP2_UFCS(name)(f)) + "", indent + 1);
@@ -7157,7 +7333,7 @@ auto sample_traverser(cpp2::impl::in<meta::function_declaration> f, cpp2::impl::
     }
 }
 
-#line 3389 "reflect.h2"
+#line 3561 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::object_declaration> o, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     sample_print("Object: name " + cpp2::to_string(CPP2_UFCS(name)(o)) + ", type " + cpp2::to_string(CPP2_UFCS(type)(o)) + "", indent);
@@ -7167,7 +7343,7 @@ auto sample_traverser(cpp2::impl::in<meta::object_declaration> o, cpp2::impl::in
     }
 }
 
-#line 3399 "reflect.h2"
+#line 3571 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::type_declaration> t, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     sample_print("Type: " + cpp2::to_string(CPP2_UFCS(name)(t)) + "", indent);
@@ -7188,7 +7364,7 @@ auto sample_traverser(cpp2::impl::in<meta::type_declaration> t, cpp2::impl::in<c
     }
 }
 
-#line 3420 "reflect.h2"
+#line 3592 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::parameter_declaration> t, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     sample_print("parameter:", indent);
@@ -7207,7 +7383,7 @@ auto sample_traverser(cpp2::impl::in<meta::parameter_declaration> t, cpp2::impl:
     sample_traverser(CPP2_UFCS(get_declaration)(t), indent + 2);
 }
 
-#line 3439 "reflect.h2"
+#line 3611 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto params {CPP2_UFCS(get_parameters)(stmt)}; 
@@ -7262,7 +7438,7 @@ auto sample_traverser(cpp2::impl::in<meta::statement> stmt, cpp2::impl::in<cpp2:
     //  jump
 }
 
-#line 3494 "reflect.h2"
+#line 3666 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::compound_statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto stmts {CPP2_UFCS(get_statements)(stmt)}; 
@@ -7279,7 +7455,7 @@ auto sample_traverser(cpp2::impl::in<meta::compound_statement> stmt, cpp2::impl:
     }
 }
 
-#line 3511 "reflect.h2"
+#line 3683 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::return_statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     sample_print("return statement", indent);
@@ -7289,7 +7465,7 @@ auto sample_traverser(cpp2::impl::in<meta::return_statement> stmt, cpp2::impl::i
     }
 }
 
-#line 3521 "reflect.h2"
+#line 3693 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::iteration_statement> stmt, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     if (CPP2_UFCS(is_do)(stmt) || CPP2_UFCS(is_while)(stmt)) {
@@ -7321,7 +7497,7 @@ auto sample_traverser(cpp2::impl::in<meta::iteration_statement> stmt, cpp2::impl
     }
 }
 
-#line 3553 "reflect.h2"
+#line 3725 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::expression> expr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     //  An expression has other shortcuts to query deeper properties,
@@ -7335,7 +7511,7 @@ auto sample_traverser(cpp2::impl::in<meta::expression> expr, cpp2::impl::in<cpp2
     }
 }
 
-#line 3567 "reflect.h2"
+#line 3739 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::assignment_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7353,7 +7529,7 @@ auto sample_traverser(cpp2::impl::in<meta::assignment_expression> binexpr, cpp2:
 {
 auto first{true};
 
-#line 3583 "reflect.h2"
+#line 3755 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7365,11 +7541,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3593 "reflect.h2"
+#line 3765 "reflect.h2"
     }
 }
 
-#line 3597 "reflect.h2"
+#line 3769 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::logical_or_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7387,7 +7563,7 @@ auto sample_traverser(cpp2::impl::in<meta::logical_or_expression> binexpr, cpp2:
 {
 auto first{true};
 
-#line 3613 "reflect.h2"
+#line 3785 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7399,11 +7575,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3623 "reflect.h2"
+#line 3795 "reflect.h2"
     }
 }
 
-#line 3627 "reflect.h2"
+#line 3799 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::logical_and_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7421,7 +7597,7 @@ auto sample_traverser(cpp2::impl::in<meta::logical_and_expression> binexpr, cpp2
 {
 auto first{true};
 
-#line 3643 "reflect.h2"
+#line 3815 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7433,11 +7609,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3653 "reflect.h2"
+#line 3825 "reflect.h2"
     }
 }
 
-#line 3657 "reflect.h2"
+#line 3829 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::bit_or_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7455,7 +7631,7 @@ auto sample_traverser(cpp2::impl::in<meta::bit_or_expression> binexpr, cpp2::imp
 {
 auto first{true};
 
-#line 3673 "reflect.h2"
+#line 3845 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7467,11 +7643,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3683 "reflect.h2"
+#line 3855 "reflect.h2"
     }
 }
 
-#line 3687 "reflect.h2"
+#line 3859 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::bit_xor_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7489,7 +7665,7 @@ auto sample_traverser(cpp2::impl::in<meta::bit_xor_expression> binexpr, cpp2::im
 {
 auto first{true};
 
-#line 3703 "reflect.h2"
+#line 3875 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7501,11 +7677,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3713 "reflect.h2"
+#line 3885 "reflect.h2"
     }
 }
 
-#line 3717 "reflect.h2"
+#line 3889 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::bit_and_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7523,7 +7699,7 @@ auto sample_traverser(cpp2::impl::in<meta::bit_and_expression> binexpr, cpp2::im
 {
 auto first{true};
 
-#line 3733 "reflect.h2"
+#line 3905 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7535,11 +7711,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3743 "reflect.h2"
+#line 3915 "reflect.h2"
     }
 }
 
-#line 3747 "reflect.h2"
+#line 3919 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::equality_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7557,7 +7733,7 @@ auto sample_traverser(cpp2::impl::in<meta::equality_expression> binexpr, cpp2::i
 {
 auto first{true};
 
-#line 3763 "reflect.h2"
+#line 3935 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7569,11 +7745,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3773 "reflect.h2"
+#line 3945 "reflect.h2"
     }
 }
 
-#line 3777 "reflect.h2"
+#line 3949 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::relational_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7591,7 +7767,7 @@ auto sample_traverser(cpp2::impl::in<meta::relational_expression> binexpr, cpp2:
 {
 auto first{true};
 
-#line 3793 "reflect.h2"
+#line 3965 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7603,11 +7779,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3803 "reflect.h2"
+#line 3975 "reflect.h2"
     }
 }
 
-#line 3807 "reflect.h2"
+#line 3979 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::compare_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7625,7 +7801,7 @@ auto sample_traverser(cpp2::impl::in<meta::compare_expression> binexpr, cpp2::im
 {
 auto first{true};
 
-#line 3823 "reflect.h2"
+#line 3995 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7637,11 +7813,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3833 "reflect.h2"
+#line 4005 "reflect.h2"
     }
 }
 
-#line 3837 "reflect.h2"
+#line 4009 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::shift_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7659,7 +7835,7 @@ auto sample_traverser(cpp2::impl::in<meta::shift_expression> binexpr, cpp2::impl
 {
 auto first{true};
 
-#line 3853 "reflect.h2"
+#line 4025 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7671,11 +7847,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3863 "reflect.h2"
+#line 4035 "reflect.h2"
     }
 }
 
-#line 3867 "reflect.h2"
+#line 4039 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::additive_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7693,7 +7869,7 @@ auto sample_traverser(cpp2::impl::in<meta::additive_expression> binexpr, cpp2::i
 {
 auto first{true};
 
-#line 3883 "reflect.h2"
+#line 4055 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7705,11 +7881,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3893 "reflect.h2"
+#line 4065 "reflect.h2"
     }
 }
 
-#line 3897 "reflect.h2"
+#line 4069 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::multiplicative_expression> binexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
@@ -7727,7 +7903,7 @@ auto sample_traverser(cpp2::impl::in<meta::multiplicative_expression> binexpr, c
 {
 auto first{true};
 
-#line 3913 "reflect.h2"
+#line 4085 "reflect.h2"
         for ( 
              auto const& term : cpp2::move(terms) ) 
         {
@@ -7739,11 +7915,11 @@ auto first{true};
             sample_traverser(CPP2_UFCS(get_term)(term), indent + 2);
         }
 }
-#line 3923 "reflect.h2"
+#line 4095 "reflect.h2"
     }
 }
 
-#line 3927 "reflect.h2"
+#line 4099 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::is_as_expression> isas, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(isas)}; 
@@ -7769,7 +7945,7 @@ auto sample_traverser(cpp2::impl::in<meta::is_as_expression> isas, cpp2::impl::i
     }
 }
 
-#line 3953 "reflect.h2"
+#line 4125 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::expression_list> exprs, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     if (CPP2_UFCS(is_empty)(exprs)) {
@@ -7784,7 +7960,7 @@ auto sample_traverser(cpp2::impl::in<meta::expression_list> exprs, cpp2::impl::i
     }
 }
 
-#line 3968 "reflect.h2"
+#line 4140 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::prefix_expression> prefix, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto ops {CPP2_UFCS(get_ops)(prefix)}; 
@@ -7808,7 +7984,7 @@ auto sample_traverser(cpp2::impl::in<meta::prefix_expression> prefix, cpp2::impl
     }
 }
 
-#line 3992 "reflect.h2"
+#line 4164 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::postfix_expression> postfix, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     auto terms {CPP2_UFCS(get_terms)(postfix)}; 
@@ -7841,7 +8017,7 @@ auto sample_traverser(cpp2::impl::in<meta::postfix_expression> postfix, cpp2::im
     }
 }
 
-#line 4025 "reflect.h2"
+#line 4197 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::unqualified_id> uid, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     if (CPP2_UFCS(is_identifier)(uid)) {
@@ -7852,13 +8028,13 @@ auto sample_traverser(cpp2::impl::in<meta::unqualified_id> uid, cpp2::impl::in<c
     }
 }
 
-#line 4036 "reflect.h2"
+#line 4208 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::qualified_id> qid, cpp2::impl::in<cpp2::i32> indent) -> void
 {
 {
 auto first{true};
 
-#line 4039 "reflect.h2"
+#line 4211 "reflect.h2"
     for ( 
          auto const& term : CPP2_UFCS(get_terms)(qid) ) 
     {
@@ -7870,10 +8046,10 @@ auto first{true};
         sample_traverser(CPP2_UFCS(get_unqualified)(term), indent + 2);
     }
 }
-#line 4049 "reflect.h2"
+#line 4221 "reflect.h2"
 }
 
-#line 4052 "reflect.h2"
+#line 4224 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::type_id> tid, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     if (CPP2_UFCS(is_postfix_expression)(tid)) {
@@ -7890,7 +8066,7 @@ auto sample_traverser(cpp2::impl::in<meta::type_id> tid, cpp2::impl::in<cpp2::i3
     }}}
 }
 
-#line 4069 "reflect.h2"
+#line 4241 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::primary_expression> primary, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     if (CPP2_UFCS(is_identifier)(primary)) {
@@ -7910,7 +8086,7 @@ auto sample_traverser(cpp2::impl::in<meta::primary_expression> primary, cpp2::im
     }}}}
 }
 
-#line 4089 "reflect.h2"
+#line 4261 "reflect.h2"
 auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in<cpp2::i32> indent) -> void
 {
     if (CPP2_UFCS(is_identifier)(idexpr)) {
@@ -7927,13 +8103,13 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
     }}}
 }
 
-#line 4106 "reflect.h2"
+#line 4278 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  autodiff
 //
 
-#line 4123 "reflect.h2"
+#line 4295 "reflect.h2"
     autodiff_special_func::autodiff_special_func(cpp2::impl::in<std::string> name_, cpp2::impl::in<int> n_args_, cpp2::impl::in<bool> is_member_, cpp2::impl::in<std::string> code_primal_, cpp2::impl::in<std::string> code_fwd_, 
                           cpp2::impl::in<std::string> code_rws_, cpp2::impl::in<std::string> code_primal_higher_order_, cpp2::impl::in<std::string> code_fwd_higher_order_, 
                           cpp2::impl::in<std::string> code_rws_higher_order_)
@@ -7947,7 +8123,7 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
         , code_fwd_higher_order{ code_fwd_higher_order_ }
         , code_rws_higher_order{ code_rws_higher_order_ }{
 
-#line 4137 "reflect.h2"
+#line 4309 "reflect.h2"
         if (CPP2_UFCS(empty)(code_primal_higher_order)) {
             code_primal_higher_order = code_primal;
         }
@@ -7959,7 +8135,7 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
         }
     }
 
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     autodiff_special_func::autodiff_special_func(autodiff_special_func const& that)
                                    : name{ that.name }
                                    , n_args{ that.n_args }
@@ -7970,7 +8146,7 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
                                    , code_primal_higher_order{ that.code_primal_higher_order }
                                    , code_fwd_higher_order{ that.code_fwd_higher_order }
                                    , code_rws_higher_order{ that.code_rws_higher_order }{}
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     auto autodiff_special_func::operator=(autodiff_special_func const& that) -> autodiff_special_func& {
                                    name = that.name;
                                    n_args = that.n_args;
@@ -7982,7 +8158,7 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
                                    code_fwd_higher_order = that.code_fwd_higher_order;
                                    code_rws_higher_order = that.code_rws_higher_order;
                                    return *this; }
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     autodiff_special_func::autodiff_special_func(autodiff_special_func&& that) noexcept
                                    : name{ std::move(that).name }
                                    , n_args{ std::move(that).n_args }
@@ -7993,7 +8169,7 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
                                    , code_primal_higher_order{ std::move(that).code_primal_higher_order }
                                    , code_fwd_higher_order{ std::move(that).code_fwd_higher_order }
                                    , code_rws_higher_order{ std::move(that).code_rws_higher_order }{}
-#line 4148 "reflect.h2"
+#line 4320 "reflect.h2"
     auto autodiff_special_func::operator=(autodiff_special_func&& that) noexcept -> autodiff_special_func& {
                                    name = std::move(that).name;
                                    n_args = std::move(that).n_args;
@@ -8006,47 +8182,47 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
                                    code_rws_higher_order = std::move(that).code_rws_higher_order;
                                    return *this; }// Default copy.
 
-#line 4150 "reflect.h2"
+#line 4322 "reflect.h2"
     [[nodiscard]] auto autodiff_special_func::is_match(cpp2::impl::in<autodiff_special_func> o) const& -> bool{
         return name == o.name && n_args == o.n_args && is_member == o.is_member; 
     }
 
-#line 4157 "reflect.h2"
+#line 4329 "reflect.h2"
                                         // TODO: Maybe use variant here.
 
-#line 4161 "reflect.h2"
+#line 4333 "reflect.h2"
     autodiff_declared_variable::autodiff_declared_variable(){}
 
-#line 4163 "reflect.h2"
+#line 4335 "reflect.h2"
     autodiff_declared_variable::autodiff_declared_variable(cpp2::impl::in<std::string> name_, cpp2::impl::in<std::string> decl_, cpp2::impl::in<bool> is_active_, cpp2::impl::in<bool> is_member_)
         : name{ name_ }
         , decl{ decl_ }
         , is_active{ is_active_ }
         , is_member{ is_member_ }{
 
-#line 4168 "reflect.h2"
+#line 4340 "reflect.h2"
     }
 
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     autodiff_declared_variable::autodiff_declared_variable(autodiff_declared_variable const& that)
                                   : name{ that.name }
                                   , decl{ that.decl }
                                   , is_active{ that.is_active }
                                   , is_member{ that.is_member }{}
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     auto autodiff_declared_variable::operator=(autodiff_declared_variable const& that) -> autodiff_declared_variable& {
                                   name = that.name;
                                   decl = that.decl;
                                   is_active = that.is_active;
                                   is_member = that.is_member;
                                   return *this; }
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     autodiff_declared_variable::autodiff_declared_variable(autodiff_declared_variable&& that) noexcept
                                   : name{ std::move(that).name }
                                   , decl{ std::move(that).decl }
                                   , is_active{ std::move(that).is_active }
                                   , is_member{ std::move(that).is_member }{}
-#line 4170 "reflect.h2"
+#line 4342 "reflect.h2"
     auto autodiff_declared_variable::operator=(autodiff_declared_variable&& that) noexcept -> autodiff_declared_variable& {
                                   name = std::move(that).name;
                                   decl = std::move(that).decl;
@@ -8054,21 +8230,21 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
                                   is_member = std::move(that).is_member;
                                   return *this; }
 
-#line 4174 "reflect.h2"
+#line 4346 "reflect.h2"
                                       // namespace + type name
 
-#line 4182 "reflect.h2"
+#line 4354 "reflect.h2"
     autodiff_declaration_stack_item::autodiff_declaration_stack_item(cpp2::impl::in<std::string> full_name_, cpp2::impl::in<meta::type_or_namespace_declaration> decl_)
         : full_name{ full_name_ }
         , decl{ decl_ }{
 
-#line 4185 "reflect.h2"
+#line 4357 "reflect.h2"
     }
 
-#line 4187 "reflect.h2"
+#line 4359 "reflect.h2"
     [[nodiscard]] auto autodiff_declaration_stack_item::lookup_declaration(cpp2::impl::in<std::string> decl_name) const& -> lookup_declaration_ret{
         std::vector<meta::declaration> r {};
-#line 4188 "reflect.h2"
+#line 4360 "reflect.h2"
         for ( auto const& cur : CPP2_UFCS(get_members)(decl) ) {
             if (CPP2_UFCS(has_name)(cur) && decl_name == CPP2_UFCS(name)(cur)) {
                 CPP2_UFCS(push_back)(r, cur);
@@ -8078,7 +8254,7 @@ auto sample_traverser(cpp2::impl::in<meta::id_expression> idexpr, cpp2::impl::in
         }return r; 
     }
 
-#line 4197 "reflect.h2"
+#line 4369 "reflect.h2"
     [[nodiscard]] auto autodiff_declaration_stack_item::lookup_variable_declaration(cpp2::impl::in<std::string> decl_name) const& -> lookup_variable_declaration_ret{
         bool found {false};
         autodiff_declared_variable r {};
@@ -8087,7 +8263,7 @@ auto cur_context{CPP2_UFCS(rbegin)(declared_variables_stack)};
         //  Note: Not using "for std::ranges::views::reverse(...)" because
         //  that does not work correctly in Clang 12 + older libstdc++
 
-#line 4201 "reflect.h2"
+#line 4373 "reflect.h2"
         for( ; cur_context != CPP2_UFCS(rend)(declared_variables_stack); 
               ++cur_context ) 
         {
@@ -8100,10 +8276,10 @@ auto cur_context{CPP2_UFCS(rbegin)(declared_variables_stack)};
             }
         }
 }
-#line 4202 "reflect.h2"
+#line 4374 "reflect.h2"
         return  { std::move(found), std::move(r) }; 
 
-#line 4212 "reflect.h2"
+#line 4384 "reflect.h2"
     }
 
     autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declaration_stack_item const& that)
@@ -8119,7 +8295,7 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
                                      , diff_done{ std::move(that).diff_done }
                                      , declared_variables_stack{ std::move(that).declared_variables_stack }{}
 
-#line 4220 "reflect.h2"
+#line 4392 "reflect.h2"
     // Code in special function is replaced. Placeholders are:
     //   _o_  : name of object for member functions.
     //   _o_  : name of derivative object for member functions.
@@ -8130,29 +8306,29 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
 
                                         /* is_member = */
 
-#line 4237 "reflect.h2"
+#line 4409 "reflect.h2"
                                         /* is_member = */
 
-#line 4245 "reflect.h2"
+#line 4417 "reflect.h2"
                                         /* is_member = */
 
-#line 4253 "reflect.h2"
+#line 4425 "reflect.h2"
                                          /* is_member = */
 
-#line 4261 "reflect.h2"
+#line 4433 "reflect.h2"
                                               /* is_member = */
 
-#line 4272 "reflect.h2"
+#line 4444 "reflect.h2"
     // Members depending on order
 
-#line 4279 "reflect.h2"
+#line 4451 "reflect.h2"
     autodiff_context::autodiff_context(){}
-#line 4280 "reflect.h2"
+#line 4452 "reflect.h2"
     autodiff_context::autodiff_context(cpp2::impl::in<int> order_, cpp2::impl::in<bool> reverse_)
         : order{ order_ }
         , reverse{ reverse_ }{
 
-#line 4284 "reflect.h2"
+#line 4456 "reflect.h2"
         if (1 != order) {
             if (reverse) {
                 fwd_ad_type = "cpp2::taylor<double, " + cpp2::to_string(order - 1) + ">";
@@ -8165,17 +8341,17 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
 
     }
 
-#line 4296 "reflect.h2"
+#line 4468 "reflect.h2"
     auto autodiff_context::add_variable_declaration(cpp2::impl::in<std::string> name, cpp2::impl::in<std::string> type, cpp2::impl::in<bool> is_active, cpp2::impl::in<bool> is_member) & -> void{
         CPP2_UFCS(push_back)(CPP2_UFCS(back)(CPP2_UFCS(back)(declaration_stack).declared_variables_stack), autodiff_declared_variable(name, type, is_active, is_member));
     }
 
-#line 4300 "reflect.h2"
+#line 4472 "reflect.h2"
     [[nodiscard]] auto autodiff_context::is_variable_active(cpp2::impl::in<std::string> name) & -> bool{
         return lookup_variable_declaration(name).is_active; 
     }
 
-#line 4304 "reflect.h2"
+#line 4476 "reflect.h2"
     auto autodiff_context::create_namespace_stack(cpp2::impl::in<meta::type_or_namespace_declaration> t) & -> void{
         if (CPP2_UFCS(parent_is_nonglobal_namespace)(t)) {
             create_namespace_stack(CPP2_UFCS(as_nonglobal_namespace)(CPP2_UFCS(get_parent)(t)));
@@ -8193,20 +8369,20 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
         static_cast<void>(CPP2_UFCS(push_back)(declaration_stack, autodiff_declaration_stack_item(cpp2::move(full_name), t)));
     }
 
-#line 4321 "reflect.h2"
+#line 4493 "reflect.h2"
     [[nodiscard]] auto autodiff_context::is_forward() const& -> decltype(auto) { return !(reverse) || (reverse && order != 1);  }
-#line 4322 "reflect.h2"
+#line 4494 "reflect.h2"
     [[nodiscard]] auto autodiff_context::is_reverse() const& -> decltype(auto) { return reverse;  }
-#line 4323 "reflect.h2"
+#line 4495 "reflect.h2"
     [[nodiscard]] auto autodiff_context::is_taylor() const& -> decltype(auto) { return order != 1;  }
 
-#line 4325 "reflect.h2"
+#line 4497 "reflect.h2"
     [[nodiscard]] auto autodiff_context::gen_temporary() & -> std::string{
         temporary_count += 1;
         return "temp_" + cpp2::to_string(temporary_count) + ""; 
     }
 
-#line 4330 "reflect.h2"
+#line 4502 "reflect.h2"
     [[nodiscard]] auto autodiff_context::is_type_active(cpp2::impl::in<std::string> type) & -> bool{
         auto decls {lookup_type_declaration(type)}; 
         auto r {false}; 
@@ -8228,7 +8404,7 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
         return r; 
     }
 
-#line 4351 "reflect.h2"
+#line 4523 "reflect.h2"
     [[nodiscard]] auto autodiff_context::get_fwd_ad_type(cpp2::impl::in<std::string> type) & -> std::string{
         auto type_d {type}; 
 
@@ -8247,7 +8423,7 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
         return string_util::replace_all(cpp2::move(type_d), "double", fwd_ad_type); 
     }
 
-#line 4369 "reflect.h2"
+#line 4541 "reflect.h2"
     [[nodiscard]] auto autodiff_context::get_rws_ad_type(cpp2::impl::in<std::string> type) & -> std::string{
         auto type_d {type}; 
 
@@ -8266,7 +8442,7 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
         return string_util::replace_all(cpp2::move(type_d), "double", rws_ad_type); 
     }
 
-#line 4387 "reflect.h2"
+#line 4559 "reflect.h2"
     [[nodiscard]] auto autodiff_context::get_reverse_passing_style(cpp2::impl::in<passing_style> p) const& -> passing_style{
         // TODO: inspect does not work here: error: error: no matching function for call to ‘is<cpp2::passing_style::in>(const cpp2::passing_style&)’
         // return inspect p -> passing_style  {
@@ -8289,13 +8465,13 @@ autodiff_declaration_stack_item::autodiff_declaration_stack_item(autodiff_declar
         if (p == passing_style::forward)     { return  passing_style::inout; }
         if (p == passing_style::forward_ref) { return  passing_style::inout; }
 
-#line 4410 "reflect.h2"
+#line 4582 "reflect.h2"
         CPP2_UFCS(error)(CPP2_UFCS(back)(declaration_stack).decl, "AD: Do not know how to handle passing style:" + cpp2::to_string(p) + "");
 
         return  passing_style::inout; 
     }
 
-#line 4415 "reflect.h2"
+#line 4587 "reflect.h2"
     [[nodiscard]] auto autodiff_context::lookup_declaration(cpp2::impl::in<std::string> decl_name) & -> lookup_declaration_ret{
         std::vector<meta::declaration> r {};
 {
@@ -8303,7 +8479,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         //  Note: Not using "for std::ranges::views::reverse(...)" because
         //  that does not work correctly in Clang 12 + older libstdc++
 
-#line 4419 "reflect.h2"
+#line 4591 "reflect.h2"
         for( ; cur != CPP2_UFCS(rend)(declaration_stack); 
               ++cur ) 
         {
@@ -8325,11 +8501,11 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         }
 }
 
-#line 4439 "reflect.h2"
+#line 4611 "reflect.h2"
         return r; 
     }
 
-#line 4442 "reflect.h2"
+#line 4614 "reflect.h2"
     [[nodiscard]] auto autodiff_context::lookup_variable_declaration(cpp2::impl::in<std::string> name) & -> autodiff_declared_variable{
         if (name == "_") {
             return autodiff_declared_variable(name, "_", false, false); 
@@ -8340,7 +8516,7 @@ auto cur_context{CPP2_UFCS(rbegin)(declaration_stack)};
         //  Note: Not using "for std::ranges::views::reverse(...)" because
         //  that does not work correctly in Clang 12 + older libstdc++
 
-#line 4450 "reflect.h2"
+#line 4622 "reflect.h2"
         for( ; cur_context != CPP2_UFCS(rend)(declaration_stack); 
               ++cur_context ) 
         {
@@ -8351,16 +8527,16 @@ auto cur_context{CPP2_UFCS(rbegin)(declaration_stack)};
         }
 }
 
-#line 4459 "reflect.h2"
+#line 4631 "reflect.h2"
         CPP2_UFCS(error)(CPP2_UFCS(back)(declaration_stack).decl, "AD: Could not find declaration of variable with name `" + cpp2::to_string(name) + "`.");
 
         return autodiff_declared_variable(); 
     }
 
-#line 4464 "reflect.h2"
+#line 4636 "reflect.h2"
     [[nodiscard]] auto autodiff_context::lookup_function_declaration(cpp2::impl::in<std::string> decl_name) & -> lookup_function_declaration_ret{
         std::vector<meta::function_declaration> r {};
-#line 4465 "reflect.h2"
+#line 4637 "reflect.h2"
         auto r_all {lookup_declaration(decl_name)}; 
 
         for ( auto const& cur : cpp2::move(r_all) ) {
@@ -8370,10 +8546,10 @@ auto cur_context{CPP2_UFCS(rbegin)(declaration_stack)};
         }return r; 
     }
 
-#line 4474 "reflect.h2"
+#line 4646 "reflect.h2"
     [[nodiscard]] auto autodiff_context::lookup_member_function_declaration(cpp2::impl::in<meta::type_declaration> obj_type, cpp2::impl::in<std::string> decl_name) & -> lookup_member_function_declaration_ret{
         std::vector<meta::function_declaration> r {};
-#line 4475 "reflect.h2"
+#line 4647 "reflect.h2"
         for ( auto const& cur : CPP2_UFCS(get_members)(obj_type) ) {
             if (CPP2_UFCS(is_function)(cur) && CPP2_UFCS(has_name)(cur) && decl_name == CPP2_UFCS(name)(cur)) {
                 CPP2_UFCS(push_back)(r, CPP2_UFCS(as_function)(cur));
@@ -8383,10 +8559,10 @@ auto cur_context{CPP2_UFCS(rbegin)(declaration_stack)};
         }return r; 
     }
 
-#line 4484 "reflect.h2"
+#line 4656 "reflect.h2"
     [[nodiscard]] auto autodiff_context::lookup_type_declaration(cpp2::impl::in<std::string> decl_name) & -> lookup_type_declaration_ret{
         std::vector<meta::type_declaration> r {};
-#line 4485 "reflect.h2"
+#line 4657 "reflect.h2"
         auto r_all {lookup_declaration(decl_name)}; 
 
         for ( auto const& cur : cpp2::move(r_all) ) {
@@ -8396,13 +8572,13 @@ auto cur_context{CPP2_UFCS(rbegin)(declaration_stack)};
         }return r; 
     }
 
-#line 4494 "reflect.h2"
+#line 4666 "reflect.h2"
     [[nodiscard]] auto autodiff_context::lookup_special_function_handling(cpp2::impl::in<std::string> func_name, cpp2::impl::in<int> n_args, cpp2::impl::in<bool> is_member) const& -> lookup_special_function_handling_ret{
             cpp2::impl::deferred_init<bool> m;
             cpp2::impl::deferred_init<std::string> code_primal;
             cpp2::impl::deferred_init<std::string> code_fwd;
             cpp2::impl::deferred_init<std::string> code_rws;
-#line 4495 "reflect.h2"
+#line 4667 "reflect.h2"
         autodiff_special_func lookup {func_name, n_args, is_member}; 
 
         m.construct(false);
@@ -8427,7 +8603,7 @@ auto cur_context{CPP2_UFCS(rbegin)(declaration_stack)};
         }return  { std::move(m.value()), std::move(code_primal.value()), std::move(code_fwd.value()), std::move(code_rws.value()) }; 
     }
 
-#line 4519 "reflect.h2"
+#line 4691 "reflect.h2"
     auto autodiff_context::add_as_differentiated(cpp2::impl::in<meta::declaration> t) & -> void{
         auto top {&CPP2_UFCS(back)(declaration_stack)}; 
 
@@ -8436,7 +8612,7 @@ auto cur_context{CPP2_UFCS(rbegin)(declaration_stack)};
         CPP2_UFCS(push_back)((*cpp2::impl::assert_not_null(cpp2::move(top))).diff_done, t);
     }
 
-#line 4527 "reflect.h2"
+#line 4699 "reflect.h2"
     auto autodiff_context::add_for_differentiation(cpp2::impl::in<meta::declaration> t) & -> void{
         auto t_parent {CPP2_UFCS(get_parent)(t)}; 
 
@@ -8447,7 +8623,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         //  Note: Not using "for std::ranges::views::reverse(...)" because
         //  that does not work correctly in Clang 12 + older libstdc++
 
-#line 4535 "reflect.h2"
+#line 4707 "reflect.h2"
         for( ; cur != CPP2_UFCS(rend)(declaration_stack); 
               ++cur ) 
         {
@@ -8462,13 +8638,13 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         }
 }
 
-#line 4548 "reflect.h2"
+#line 4720 "reflect.h2"
         if (!(cpp2::move(found))) {
             CPP2_UFCS(error)(t, "AD: Could not find parent type/namespace for: " + cpp2::to_string(t) + "");
         }
     }
 
-#line 4553 "reflect.h2"
+#line 4725 "reflect.h2"
     [[nodiscard]] auto autodiff_context::is_in_list(cpp2::impl::in<meta::declaration> v, cpp2::impl::in<std::vector<meta::declaration>> list) -> bool{
         for ( auto const& cur : list ) {
             if (CPP2_UFCS(is_same)(cur, v)) {
@@ -8479,18 +8655,18 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         return false; 
     }
 
-#line 4563 "reflect.h2"
+#line 4735 "reflect.h2"
     auto autodiff_context::enter_function() & -> void{
         temporary_count = 0;
         CPP2_UFCS(push_back)(CPP2_UFCS(back)(declaration_stack).declared_variables_stack, std::vector<autodiff_declared_variable>());
     }
 
-#line 4568 "reflect.h2"
+#line 4740 "reflect.h2"
     auto autodiff_context::leave_function() & -> void{
         CPP2_UFCS(pop_back)(CPP2_UFCS(back)(declaration_stack).declared_variables_stack);
     }
 
-#line 4572 "reflect.h2"
+#line 4744 "reflect.h2"
     auto autodiff_context::push_stack(cpp2::impl::in<meta::type_or_namespace_declaration> decl) & -> void{
         std::string full_name {""}; 
 
@@ -8504,7 +8680,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         CPP2_UFCS(push_back)(declaration_stack, autodiff_declaration_stack_item(cpp2::move(full_name), decl));
     }
 
-#line 4585 "reflect.h2"
+#line 4757 "reflect.h2"
     auto autodiff_context::pop_stack() & -> void{
         if (cpp2::cpp2_default.is_active() && !(!(CPP2_UFCS(empty)(declaration_stack))) ) { cpp2::cpp2_default.report_violation(""); }
 
@@ -8520,7 +8696,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         CPP2_UFCS(pop_back)(declaration_stack);
     }
 
-#line 4600 "reflect.h2"
+#line 4772 "reflect.h2"
     auto autodiff_context::finish() & -> void{
         while( !(CPP2_UFCS(empty)(declaration_stack)) ) {
             pop_stack();
@@ -8528,18 +8704,18 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
     }
 
     //TODO: Remove when autodiff_diff_code is updated
-#line 4607 "reflect.h2"
+#line 4779 "reflect.h2"
     [[nodiscard]] auto autodiff_context::get_self() & -> autodiff_context*{
         return &(*this); 
     }
 
-#line 4620 "reflect.h2"
+#line 4792 "reflect.h2"
     autodiff_diff_code::autodiff_diff_code(cpp2::impl::in<autodiff_context*> ctx_)
         : ctx{ ctx_ }{
 
-#line 4622 "reflect.h2"
+#line 4794 "reflect.h2"
     }
-#line 4620 "reflect.h2"
+#line 4792 "reflect.h2"
     auto autodiff_diff_code::operator=(cpp2::impl::in<autodiff_context*> ctx_) -> autodiff_diff_code& {
         ctx = ctx_;
         fwd = "";
@@ -8547,28 +8723,28 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         rws_backprop = "";
         return *this;
 
-#line 4622 "reflect.h2"
+#line 4794 "reflect.h2"
     }
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     autodiff_diff_code::autodiff_diff_code(autodiff_diff_code const& that)
                                   : ctx{ that.ctx }
                                   , fwd{ that.fwd }
                                   , rws_primal{ that.rws_primal }
                                   , rws_backprop{ that.rws_backprop }{}
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     auto autodiff_diff_code::operator=(autodiff_diff_code const& that) -> autodiff_diff_code& {
                                   ctx = that.ctx;
                                   fwd = that.fwd;
                                   rws_primal = that.rws_primal;
                                   rws_backprop = that.rws_backprop;
                                   return *this; }
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     autodiff_diff_code::autodiff_diff_code(autodiff_diff_code&& that) noexcept
                                   : ctx{ std::move(that).ctx }
                                   , fwd{ std::move(that).fwd }
                                   , rws_primal{ std::move(that).rws_primal }
                                   , rws_backprop{ std::move(that).rws_backprop }{}
-#line 4623 "reflect.h2"
+#line 4795 "reflect.h2"
     auto autodiff_diff_code::operator=(autodiff_diff_code&& that) noexcept -> autodiff_diff_code& {
                                   ctx = std::move(that).ctx;
                                   fwd = std::move(that).fwd;
@@ -8576,14 +8752,14 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
                                   rws_backprop = std::move(that).rws_backprop;
                                   return *this; }
 
-#line 4625 "reflect.h2"
+#line 4797 "reflect.h2"
     auto autodiff_diff_code::add_forward(cpp2::impl::in<std::string> v) & -> void{if (CPP2_UFCS(is_forward)((*cpp2::impl::assert_not_null(ctx)))) {fwd += v;}}
-#line 4626 "reflect.h2"
+#line 4798 "reflect.h2"
     auto autodiff_diff_code::add_reverse_primal(cpp2::impl::in<std::string> v) & -> void{if (CPP2_UFCS(is_reverse)((*cpp2::impl::assert_not_null(ctx)))) {rws_primal += v;}}
-#line 4627 "reflect.h2"
+#line 4799 "reflect.h2"
     auto autodiff_diff_code::add_reverse_backprop(cpp2::impl::in<std::string> v) & -> void{if (CPP2_UFCS(is_reverse)((*cpp2::impl::assert_not_null(ctx)))) {rws_backprop = v + rws_backprop; }}
 
-#line 4629 "reflect.h2"
+#line 4801 "reflect.h2"
     auto autodiff_diff_code::reset() & -> void{
         fwd          = "";
         rws_primal   = "";
@@ -8591,7 +8767,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
     }
 
     // Temporary: TODO: remove when everything has been adapted to primal, fwd, rws pushes.
-#line 4636 "reflect.h2"
+#line 4808 "reflect.h2"
     auto autodiff_diff_code::operator=(cpp2::impl::in<std::string> v) -> autodiff_diff_code& {
         ctx = CPP2_UFCS_NONLOCAL(get_self)((*cpp2::impl::assert_not_null(ctx)));
         fwd = v;
@@ -8599,42 +8775,42 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         rws_backprop = "";
         return *this;
 
-#line 4639 "reflect.h2"
+#line 4811 "reflect.h2"
     }
 
     // Temporary: TODO: remove when everything has been adapted to primal, fwd, rws pushes.
-#line 4642 "reflect.h2"
+#line 4814 "reflect.h2"
     auto autodiff_diff_code::operator+=(cpp2::impl::in<std::string> v) & -> void{
         fwd += v;
     }
 
     // Temporary: TODO: remove when everything has been adapted to primal, fwd, rws pushes.
-#line 4647 "reflect.h2"
+#line 4819 "reflect.h2"
     auto autodiff_diff_code::operator+=(cpp2::impl::in<autodiff_diff_code> v) & -> void{
         fwd += v.fwd;
     }
 
     // Temporary: TODO: remove when everything has been adapted to primal, fwd, rws pushes.
-#line 4652 "reflect.h2"
+#line 4824 "reflect.h2"
     [[nodiscard]] auto autodiff_diff_code::empty() const& -> bool{
         return CPP2_UFCS(empty)(fwd); 
     }
 
-#line 4657 "reflect.h2"
+#line 4829 "reflect.h2"
 // // Temporary: TODO: remove when everything has been adapted to primal, fwd, rws pushes.
 // to_string: (v: autodiff_diff_code) -> std::string = {
 //     return v.fwd;
 // }
 
-#line 4668 "reflect.h2"
+#line 4840 "reflect.h2"
     autodiff_activity_check::autodiff_activity_check(cpp2::impl::in<autodiff_context*> ctx_)
         : simple_traverser{  }
         , ctx{ ctx_ }{
 
-#line 4670 "reflect.h2"
+#line 4842 "reflect.h2"
     }
 
-#line 4672 "reflect.h2"
+#line 4844 "reflect.h2"
     auto autodiff_activity_check::traverse(cpp2::impl::in<meta::type_declaration> t) -> void{
         for ( 
              auto const& m : CPP2_UFCS(get_members)(t) ) 
@@ -8647,7 +8823,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         }
     }
 
-#line 4684 "reflect.h2"
+#line 4856 "reflect.h2"
     auto autodiff_activity_check::traverse(cpp2::impl::in<meta::object_declaration> o) -> void{
 
         auto type {o.type()}; 
@@ -8666,7 +8842,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         }
     }
 
-#line 4702 "reflect.h2"
+#line 4874 "reflect.h2"
     auto autodiff_activity_check::traverse(cpp2::impl::in<meta::primary_expression> primary) -> void
     {
         if (CPP2_UFCS(is_identifier)(primary)) {
@@ -8691,7 +8867,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
         }}}}
     }
 
-#line 4726 "reflect.h2"
+#line 4898 "reflect.h2"
     auto autodiff_activity_check::traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(postfix)}; 
@@ -8700,7 +8876,7 @@ auto cur{CPP2_UFCS(rbegin)(declaration_stack)};
 {
 auto i{0};
 
-#line 4733 "reflect.h2"
+#line 4905 "reflect.h2"
         for (                     auto const& term : terms )  { do {
             if (CPP2_UFCS(get_op)(term) == ".") {
                 continue;
@@ -8716,7 +8892,7 @@ auto i{0};
 }
 
         // TODO: Really check for members
-#line 4747 "reflect.h2"
+#line 4919 "reflect.h2"
         if (!(is_func) || CPP2_UFCS(ssize)(terms) != 1) {
             active |= CPP2_UFCS(is_variable_active)((*cpp2::impl::assert_not_null(ctx)), CPP2_UFCS(to_string)(CPP2_UFCS(get_primary_expression)(postfix)));
         }
@@ -8729,39 +8905,39 @@ auto i{0};
         }
     }
 
-#line 4765 "reflect.h2"
+#line 4937 "reflect.h2"
     autodiff_handler_base::autodiff_handler_base(cpp2::impl::in<autodiff_context*> ctx_)
         : ctx{ ctx_ }
         , diff{ ctx }{
 
-#line 4768 "reflect.h2"
+#line 4940 "reflect.h2"
     }
-#line 4765 "reflect.h2"
+#line 4937 "reflect.h2"
     auto autodiff_handler_base::operator=(cpp2::impl::in<autodiff_context*> ctx_) -> autodiff_handler_base& {
         ctx = ctx_;
         diff = ctx;
         return *this;
 
-#line 4768 "reflect.h2"
+#line 4940 "reflect.h2"
     }
 
     // Temporary: TODO: remove when everything has been adapted to primal, fwd, rws pushes.
-#line 4771 "reflect.h2"
+#line 4943 "reflect.h2"
     auto autodiff_handler_base::append(autodiff_handler_base const& o) & -> void{
         diff.fwd          += o.diff.fwd;
         diff.rws_primal   += o.diff.rws_primal;
         diff.rws_backprop  = o.diff.rws_backprop + diff.rws_backprop;
     }
 
-#line 4788 "reflect.h2"
+#line 4960 "reflect.h2"
     autodiff_expression_handler::autodiff_expression_handler(cpp2::impl::in<autodiff_context*> ctx_)
         : simple_traverser{  }
         , autodiff_handler_base{ ctx_ }{
 
-#line 4790 "reflect.h2"
+#line 4962 "reflect.h2"
     }
 
-#line 4792 "reflect.h2"
+#line 4964 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::add_suffix_if_not_wildcard(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> suffix) const& -> std::string{
         if ("_" == lhs) {
             return lhs; 
@@ -8771,7 +8947,7 @@ auto i{0};
         }
     }
 
-#line 4801 "reflect.h2"
+#line 4973 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::prepare_backprop(cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b) const& -> std::string{
         auto r {rhs_b}; 
         r  = string_util::replace_all(r, "_r_", lhs);
@@ -8780,10 +8956,10 @@ auto i{0};
 
         return r; 
     }
-#line 4809 "reflect.h2"
+#line 4981 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::prepare_backprop(cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> lhs) const& -> std::string { return prepare_backprop(rhs_b, lhs, lhs + (*cpp2::impl::assert_not_null(ctx)).fwd_suffix, lhs + (*cpp2::impl::assert_not_null(ctx)).rws_suffix);  }
 
-#line 4811 "reflect.h2"
+#line 4983 "reflect.h2"
     auto autodiff_expression_handler::gen_assignment(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> rhs, cpp2::impl::in<std::string> rhs_d, cpp2::impl::in<std::string> rhs_b) & -> void{
         CPP2_UFCS(add_forward)(diff, "" + cpp2::to_string(lhs_d) + " = " + cpp2::to_string(rhs_d) + ";\n");
         CPP2_UFCS(add_forward)(diff, "" + cpp2::to_string(lhs) + "   = " + cpp2::to_string(rhs) + ";\n");
@@ -8795,14 +8971,14 @@ auto i{0};
         CPP2_UFCS(add_reverse_backprop)(diff, "" + cpp2::to_string(lhs_b) + " = 0.0;\n");
         CPP2_UFCS(add_reverse_backprop)(diff, prepare_backprop(rhs_b, lhs, lhs_d, lhs_b));
     }
-#line 4822 "reflect.h2"
+#line 4994 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::gen_assignment(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b) & -> decltype(auto) { 
         return gen_assignment(lhs, lhs_d, lhs_b, primal_expr, fwd_expr, rws_expr);  }
-#line 4824 "reflect.h2"
+#line 4996 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::gen_assignment(cpp2::impl::in<std::string> lhs) & -> decltype(auto) { 
         return gen_assignment(lhs, add_suffix_if_not_wildcard(lhs, (*cpp2::impl::assert_not_null(ctx)).fwd_suffix), add_suffix_if_not_wildcard(lhs, (*cpp2::impl::assert_not_null(ctx)).rws_suffix), primal_expr, fwd_expr, rws_expr);  }
 
-#line 4828 "reflect.h2"
+#line 5000 "reflect.h2"
     auto autodiff_expression_handler::gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> rhs, cpp2::impl::in<std::string> rhs_d, cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> type, cpp2::impl::in<std::string> type_d, cpp2::impl::in<std::string> type_b) & -> void{
         CPP2_UFCS(add_forward)(diff, "" + cpp2::to_string(lhs_d) + ": " + cpp2::to_string(type_d) + " = " + cpp2::to_string(rhs_d) + ";\n");
         CPP2_UFCS(add_forward)(diff, "" + cpp2::to_string(lhs) + "  : " + cpp2::to_string(type) + " = " + cpp2::to_string(rhs) + ";\n");
@@ -8815,13 +8991,13 @@ auto i{0};
         CPP2_UFCS(add_reverse_backprop)(diff, "" + cpp2::to_string(lhs_b) + " = 0.0;\n");
         CPP2_UFCS(add_reverse_backprop)(diff, prepare_backprop(rhs_b, lhs, lhs_d, lhs_b));
     }
-#line 4840 "reflect.h2"
+#line 5012 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> rhs, cpp2::impl::in<std::string> rhs_d, cpp2::impl::in<std::string> rhs_b, cpp2::impl::in<std::string> type) & -> decltype(auto) { 
         return gen_declaration(lhs, lhs_d, lhs_b, rhs, rhs_d, rhs_b, type, CPP2_UFCS(get_fwd_ad_type)((*cpp2::impl::assert_not_null(ctx)), type), CPP2_UFCS(get_rws_ad_type)((*cpp2::impl::assert_not_null(ctx)), type));  }
-#line 4842 "reflect.h2"
+#line 5014 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> lhs_d, cpp2::impl::in<std::string> lhs_b, cpp2::impl::in<std::string> type) & -> decltype(auto) { 
         return gen_declaration(lhs, lhs_d, lhs_b, primal_expr, fwd_expr, rws_expr, type);  }
-#line 4844 "reflect.h2"
+#line 5016 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::gen_declaration(cpp2::impl::in<std::string> lhs, cpp2::impl::in<std::string> type) & -> decltype(auto) { 
         return gen_declaration(lhs, lhs + (*cpp2::impl::assert_not_null(ctx)).fwd_suffix, lhs + (*cpp2::impl::assert_not_null(ctx)).rws_suffix, type);  }
 
@@ -8832,7 +9008,7 @@ auto i{0};
                                                                        , active{ active_ }{}
 autodiff_expression_handler::primal_fwd_rws_name::primal_fwd_rws_name(){}
 
-#line 4856 "reflect.h2"
+#line 5028 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::handle_expression_list(cpp2::impl::in<meta::expression_list> list) & -> std::vector<primal_fwd_rws_name>{
         std::vector<primal_fwd_rws_name> args {}; 
         for ( auto const& expr : CPP2_UFCS(get_expressions)(list) ) {
@@ -8842,7 +9018,7 @@ autodiff_expression_handler::primal_fwd_rws_name::primal_fwd_rws_name(){}
         return args; 
     }
 
-#line 4865 "reflect.h2"
+#line 5037 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::handle_expression_term(auto const& term) & -> primal_fwd_rws_name{
         if (CPP2_UFCS(is_identifier)(term)) {
             auto primal {CPP2_UFCS(to_string)(term)}; 
@@ -8904,7 +9080,7 @@ autodiff_expression_handler::primal_fwd_rws_name::primal_fwd_rws_name(){}
         }}
     }
 
-#line 4926 "reflect.h2"
+#line 5098 "reflect.h2"
     auto autodiff_expression_handler::handle_function_call(cpp2::impl::in<meta::postfix_expression> postfix, cpp2::impl::in<bool> has_return) & -> void{
         auto terms {CPP2_UFCS(get_terms)(postfix)}; 
 
@@ -8912,7 +9088,7 @@ autodiff_expression_handler::primal_fwd_rws_name::primal_fwd_rws_name(){}
 {
 auto i{0};
 
-#line 4932 "reflect.h2"
+#line 5104 "reflect.h2"
         for (                     auto const& term : terms )  { do {
             if (CPP2_UFCS(get_op)(term) == ".") {
                 continue;
@@ -8926,7 +9102,7 @@ auto i{0};
 }
 
         // Check for function call, everything else is not handled.
-#line 4944 "reflect.h2"
+#line 5116 "reflect.h2"
         if (!((cpp2::move(is_func)))) {
             CPP2_UFCS(error)(postfix, "AD: Postfix expressions are only handled for function calls, or member function calls. Do not know how to handle: " + cpp2::to_string(CPP2_UFCS(to_string)(postfix)) + "");
             return ; 
@@ -8951,7 +9127,7 @@ auto i{0};
 {
 auto i{0};
 
-#line 4967 "reflect.h2"
+#line 5139 "reflect.h2"
         for (                     auto const& term : terms )  { do {
             if (CPP2_UFCS(get_op)(term) == ".") {
                 if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(is_id_expression)(term)) ) { cpp2::cpp2_default.report_violation(""); }
@@ -8976,7 +9152,7 @@ auto i{0};
         } while (false); i += 1; }
 }
 
-#line 4990 "reflect.h2"
+#line 5162 "reflect.h2"
         if (handle_special_function(object, object_d, object_b, function_name, args)) {
             return ; 
         }
@@ -9093,7 +9269,7 @@ auto i{0};
         // TODO: Add function to list of functions/objects for differentiation for the no return case.
     }
 
-#line 5106 "reflect.h2"
+#line 5278 "reflect.h2"
     [[nodiscard]] auto autodiff_expression_handler::handle_special_function(cpp2::impl::in<std::string> object, cpp2::impl::in<std::string> object_d, cpp2::impl::in<std::string> object_b, cpp2::impl::in<std::string> function_name, cpp2::impl::in<std::vector<primal_fwd_rws_name>> args) & -> bool{
 
         auto r {CPP2_UFCS(lookup_special_function_handling)((*cpp2::impl::assert_not_null(ctx)), function_name, cpp2::unchecked_narrow<int>(CPP2_UFCS(ssize)(args)), !(CPP2_UFCS(empty)(object)))}; 
@@ -9121,7 +9297,7 @@ auto i{0};
 {
 auto i{1};
 
-#line 5132 "reflect.h2"
+#line 5304 "reflect.h2"
         for ( auto const& arg : args ) {
             code_primal = string_util::replace_all(code_primal, "_a" + cpp2::to_string(i) + "_", arg.primal);
             code_primal = string_util::replace_all(code_primal, "_ad" + cpp2::to_string(i) + "_", arg.fwd);
@@ -9135,7 +9311,7 @@ auto i{1};
         }
 }
 
-#line 5144 "reflect.h2"
+#line 5316 "reflect.h2"
         primal_expr = cpp2::move(code_primal);
         fwd_expr    = cpp2::move(code_fwd);
         rws_expr    = cpp2::move(code_rws);
@@ -9143,62 +9319,62 @@ auto i{1};
         return true; 
     }
 
-#line 5151 "reflect.h2"
+#line 5323 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::expression> expr) -> void{
         base::traverse(expr);
     }
 
-#line 5155 "reflect.h2"
+#line 5327 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Assign expressions are not yet handled.");
     }
 
-#line 5159 "reflect.h2"
+#line 5331 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Logical or expressions are not yet handled.");
     }
 
-#line 5163 "reflect.h2"
+#line 5335 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Logical and expressions are not yet handled.");
     }
 
-#line 5167 "reflect.h2"
+#line 5339 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Bit or expressions are not yet handled.");
     }
 
-#line 5171 "reflect.h2"
+#line 5343 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Bit xor expressions are not yet handled.");
     }
 
-#line 5175 "reflect.h2"
+#line 5347 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Bit and expressions are not yet handled.");
     }
 
-#line 5179 "reflect.h2"
+#line 5351 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Equality or expressions are not yet handled.");
     }
 
-#line 5183 "reflect.h2"
+#line 5355 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Relational expressions are not yet handled.");
     }
 
-#line 5187 "reflect.h2"
+#line 5359 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Compare or expressions are not yet handled.");
     }
 
-#line 5191 "reflect.h2"
+#line 5363 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Shift or expressions are not yet handled.");
     }
 
-#line 5195 "reflect.h2"
+#line 5367 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void{
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
 
@@ -9241,7 +9417,7 @@ auto i{1};
         rws_expr    = cpp2::move(rws);
     }
 
-#line 5237 "reflect.h2"
+#line 5409 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void{
         auto terms {CPP2_UFCS(get_terms)(binexpr)}; 
 
@@ -9312,7 +9488,7 @@ auto i{1};
                 CPP2_UFCS(error)(binexpr, "unkown multiplicative operator '" + cpp2::to_string(cpp2::move(op)) + "'");
             }}
 
-#line 5308 "reflect.h2"
+#line 5480 "reflect.h2"
             if (i + 1 == CPP2_UFCS(ssize)(terms)) {
                 primal_expr = cpp2::move(primal);
                 fwd_expr    = cpp2::move(fwd);
@@ -9329,12 +9505,12 @@ auto i{1};
         }
     }
 
-#line 5324 "reflect.h2"
+#line 5496 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void{
         CPP2_UFCS(error)(isas, "AD: Is as expressions are not yet handled.");
     }
 
-#line 5328 "reflect.h2"
+#line 5500 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void
     {
         auto ops {CPP2_UFCS(get_ops)(prefix)}; 
@@ -9351,7 +9527,7 @@ auto i{1};
         fwd_expr    = CPP2_ASSERT_IN_BOUNDS_LITERAL(cpp2::move(ops), 0) + cpp2::move(ad).fwd_expr;
     }
 
-#line 5344 "reflect.h2"
+#line 5516 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(postfix)}; 
@@ -9360,7 +9536,7 @@ auto i{1};
 {
 auto i{0};
 
-#line 5351 "reflect.h2"
+#line 5523 "reflect.h2"
         for (                     auto const& term : terms )  { do {
             if (CPP2_UFCS(get_op)(term) == ".") {
                 continue;
@@ -9375,7 +9551,7 @@ auto i{0};
         } while (false); i += 1; }
 }
 
-#line 5364 "reflect.h2"
+#line 5536 "reflect.h2"
         if (cpp2::move(is_func)) {
             handle_function_call(postfix, true);
         }
@@ -9396,7 +9572,7 @@ auto i{0};
         }
     }
 
-#line 5384 "reflect.h2"
+#line 5556 "reflect.h2"
     auto autodiff_expression_handler::traverse(cpp2::impl::in<meta::primary_expression> primary) -> void
     {
         if (CPP2_UFCS(is_identifier)(primary)) {
@@ -9433,16 +9609,16 @@ auto i{0};
         }}}}
     }
 
-#line 5434 "reflect.h2"
+#line 5606 "reflect.h2"
     autodiff_stmt_handler::autodiff_stmt_handler(cpp2::impl::in<autodiff_context*> ctx_, cpp2::impl::in<meta::function_declaration> mf_)
         : simple_traverser{  }
         , autodiff_handler_base{ ctx_ }
         , mf{ mf_ }{
 
-#line 5437 "reflect.h2"
+#line 5609 "reflect.h2"
     }
 
-#line 5439 "reflect.h2"
+#line 5611 "reflect.h2"
     [[nodiscard]] auto autodiff_stmt_handler::handle_stmt_parameters(cpp2::impl::in<std::vector<parameter_declaration>> params) & -> autodiff_diff_code{
         autodiff_diff_code r {ctx}; 
         if (CPP2_UFCS(empty)(params)) {
@@ -9472,7 +9648,7 @@ auto i{0};
                 }
             }
 
-#line 5469 "reflect.h2"
+#line 5641 "reflect.h2"
             CPP2_UFCS(add_forward)(r, "" + cpp2::to_string(fwd_pass_style) + " " + cpp2::to_string(name) + " : " + cpp2::to_string(type) + cpp2::to_string(init) + ", ");
             CPP2_UFCS(add_reverse_primal)(r, "" + cpp2::to_string(fwd_pass_style) + " " + cpp2::to_string(name) + " : " + cpp2::to_string(type) + cpp2::to_string(cpp2::move(init)) + ", ");
             if (ada.active) {
@@ -9485,17 +9661,17 @@ auto i{0};
         return r; 
     }
 
-#line 5481 "reflect.h2"
+#line 5653 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::declaration> decl) -> void{
         base::traverse(decl);
     }
 
-#line 5486 "reflect.h2"
+#line 5658 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::function_declaration> f) -> void{
         CPP2_UFCS(error)(f, "AD: Do not know how to handle function_declaration: " + cpp2::to_string(CPP2_UFCS(to_string)(f)) + "");
     }
 
-#line 5491 "reflect.h2"
+#line 5663 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::object_declaration> o) -> void{
         std::string lhs {CPP2_UFCS(name)(o)}; 
         auto type {o.type()}; 
@@ -9557,24 +9733,24 @@ auto i{0};
         CPP2_UFCS(add_variable_declaration)((*cpp2::impl::assert_not_null(ctx)), cpp2::move(lhs), cpp2::move(type), cpp2::move(active));
     }
 
-#line 5553 "reflect.h2"
+#line 5725 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::type_declaration> t) -> void{
         CPP2_UFCS(error)(t, "AD: Do not know how to handle type_declaration: " + cpp2::to_string(CPP2_UFCS(to_string)(t)) + "");
     }
 
-#line 5558 "reflect.h2"
+#line 5730 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void{
         CPP2_UFCS(error)(t, "AD: Do not know how to handle parameter_declaration: " + cpp2::to_string(CPP2_UFCS(to_string)(t)) + "");
     }
 
-#line 5563 "reflect.h2"
+#line 5735 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::statement> stmt) -> void{
         // TODO: Remove this hack when statements like compound_statement can access their root statement.
         last_params = CPP2_UFCS(get_parameters)(stmt);
         base::traverse(stmt);
     }
 
-#line 5570 "reflect.h2"
+#line 5742 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::compound_statement> stmt) -> void{
         autodiff_stmt_handler ad {ctx, mf}; 
         autodiff_stmt_handler ad_push_pop {ctx, mf}; 
@@ -9609,7 +9785,7 @@ auto i{0};
         CPP2_UFCS(add_reverse_backprop)(diff, "{\n");
     }
 
-#line 5605 "reflect.h2"
+#line 5777 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::return_statement> stmt) -> void{
         if (CPP2_UFCS(has_expression)(stmt)) {
             // Return with expression.
@@ -9626,7 +9802,7 @@ auto i{0};
         }
     }
 
-#line 5621 "reflect.h2"
+#line 5793 "reflect.h2"
     [[nodiscard]] auto autodiff_stmt_handler::reverse_next(cpp2::impl::in<std::string> expr) const& -> std::string{
         if (CPP2_UFCS(contains)(expr, "+=")) {
             return string_util::replace_all(expr, "+=", "-="); 
@@ -9641,7 +9817,7 @@ auto i{0};
 
     }
 
-#line 5636 "reflect.h2"
+#line 5808 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::iteration_statement> stmt) -> void{
         auto diff_params {handle_stmt_parameters(last_params)}; 
 
@@ -9739,7 +9915,7 @@ auto i{0};
         }}
     }
 
-#line 5734 "reflect.h2"
+#line 5906 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::selection_statement> stmt) -> void{
         // TODO: Currently assuming that nothing bad happens in the condition
         diff += "if " + cpp2::to_string(CPP2_UFCS(to_string)(CPP2_UFCS(get_expression)(stmt))) + "";
@@ -9751,12 +9927,12 @@ auto i{0};
         }
     }
 
-#line 5745 "reflect.h2"
+#line 5917 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::expression> expr) -> void{
         base::traverse(expr);
     }
 
-#line 5749 "reflect.h2"
+#line 5921 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::assignment_expression> binexpr) -> void{
         autodiff_activity_check ada {ctx}; 
         CPP2_UFCS(pre_traverse)(ada, CPP2_UFCS(get_lhs_postfix_expression)(binexpr));
@@ -9808,73 +9984,73 @@ auto i{0};
         }
     }
 
-#line 5800 "reflect.h2"
+#line 5972 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::logical_or_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Logical or expressions are not yet handled as standalone statements.");
     }
 
-#line 5804 "reflect.h2"
+#line 5976 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::logical_and_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Logical and expressions are not yet handled as standalone statements.");
     }
 
-#line 5808 "reflect.h2"
+#line 5980 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::bit_or_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Bit or expressions are not yet handled as standalone statements.");
     }
 
-#line 5812 "reflect.h2"
+#line 5984 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::bit_xor_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Bit xor expressions are not yet handled as standalone statements.");
     }
 
-#line 5816 "reflect.h2"
+#line 5988 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::bit_and_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Bit and expressions are not yet handled as standalone statements.");
     }
 
-#line 5820 "reflect.h2"
+#line 5992 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::equality_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Equality or expressions are not yet handled as standalone statements.");
     }
 
-#line 5824 "reflect.h2"
+#line 5996 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::relational_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Relational expressions are not yet handled as standalone statements.");
     }
 
-#line 5828 "reflect.h2"
+#line 6000 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::compare_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Compare or expressions are not yet handled as standalone statements.");
     }
 
-#line 5832 "reflect.h2"
+#line 6004 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::shift_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Shift or expressions are not yet handled as standalone statements.");
     }
 
-#line 5836 "reflect.h2"
+#line 6008 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::additive_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Additive expressions are not yet handled as standalone statements.");
     }
 
-#line 5840 "reflect.h2"
+#line 6012 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::multiplicative_expression> binexpr) -> void{
         CPP2_UFCS(error)(binexpr, "AD: Multiplicative expressions are not yet handled as standalone statements.");
     }
 
-#line 5844 "reflect.h2"
+#line 6016 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::is_as_expression> isas) -> void{
         CPP2_UFCS(error)(isas, "AD: Is as expressions are not yet handled as standalone statements.");
     }
 
-#line 5848 "reflect.h2"
+#line 6020 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::prefix_expression> prefix) -> void
     {
         CPP2_UFCS(error)(prefix, "AD: Prefix expressions are not yet handled as standalone statements.");
     }
 
-#line 5853 "reflect.h2"
+#line 6025 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::postfix_expression> postfix) -> void
     {
         auto terms {CPP2_UFCS(get_terms)(postfix)}; 
@@ -9883,7 +10059,7 @@ auto i{0};
 {
 auto i{0};
 
-#line 5860 "reflect.h2"
+#line 6032 "reflect.h2"
         for (                     auto const& term : terms )  { do {
             if (CPP2_UFCS(get_op)(term) == ".") {
                 continue;
@@ -9898,7 +10074,7 @@ auto i{0};
 }
 
         // Check for function call, everything else is not handled.
-#line 5873 "reflect.h2"
+#line 6045 "reflect.h2"
         if (!((cpp2::move(is_func)))) {
             CPP2_UFCS(error)(postfix, "AD: Postfix expressions are only handled for function calls, or member function calls. Do not know how to handle: " + cpp2::to_string(CPP2_UFCS(to_string)(postfix)) + "");
             return ; 
@@ -9911,27 +10087,27 @@ auto i{0};
         append(cpp2::move(ad));
     }
 
-#line 5885 "reflect.h2"
+#line 6057 "reflect.h2"
     auto autodiff_stmt_handler::traverse(cpp2::impl::in<meta::primary_expression> primary) -> void
     {
         CPP2_UFCS(error)(primary, "AD: Primary expressions are not yet handled as standalone statements.");
     }
 
-#line 5902 "reflect.h2"
+#line 6074 "reflect.h2"
     autodiff_declaration_handler::autodiff_declaration_handler(cpp2::impl::in<autodiff_context*> ctx_, cpp2::impl::in<meta::type_or_namespace_declaration> decl_)
         : simple_traverser{  }
         , autodiff_handler_base{ ctx_ }
         , decl{ decl_ }{
 
-#line 5905 "reflect.h2"
+#line 6077 "reflect.h2"
     }
 
-#line 5907 "reflect.h2"
+#line 6079 "reflect.h2"
     auto autodiff_declaration_handler::traverse(cpp2::impl::in<meta::declaration> decl_) -> void{
         base::traverse(decl_);
     }
 
-#line 5912 "reflect.h2"
+#line 6084 "reflect.h2"
     auto autodiff_declaration_handler::traverse(cpp2::impl::in<meta::function_declaration> f) -> void{
         CPP2_UFCS(enter_function)((*cpp2::impl::assert_not_null(ctx)));
 
@@ -10061,10 +10237,10 @@ auto i{0};
             return ; 
         }
 
-#line 6042 "reflect.h2"
+#line 6214 "reflect.h2"
         autodiff_stmt_handler ad_impl {&*cpp2::impl::assert_not_null(ctx), f}; 
 
-#line 6045 "reflect.h2"
+#line 6217 "reflect.h2"
         for ( auto const& stmt : CPP2_UFCS(get_statements)(CPP2_UFCS(get_compound_body)(f)) ) 
         {
             ad_impl.pre_traverse(stmt);
@@ -10089,7 +10265,7 @@ auto i{0};
         CPP2_UFCS(add_as_differentiated)((*cpp2::impl::assert_not_null(ctx)), f);
     }
 
-#line 6070 "reflect.h2"
+#line 6242 "reflect.h2"
     auto autodiff_declaration_handler::traverse(cpp2::impl::in<meta::object_declaration> o) -> void{
         std::string ad_name {"" + cpp2::to_string(CPP2_UFCS(name)(o)) + cpp2::to_string((*cpp2::impl::assert_not_null(ctx)).fwd_suffix) + ""}; 
         std::string fwd_ad_type {CPP2_UFCS(get_fwd_ad_type)((*cpp2::impl::assert_not_null(ctx)), CPP2_UFCS(type)(o))}; 
@@ -10117,7 +10293,7 @@ auto i{0};
         CPP2_UFCS(add_variable_declaration)((*cpp2::impl::assert_not_null(ctx)), "" + cpp2::to_string(CPP2_UFCS(name)(o)) + "", "" + cpp2::to_string(CPP2_UFCS(type)(o)) + "", true, true);// TODO_a: Add acitivty check
     }
 
-#line 6098 "reflect.h2"
+#line 6270 "reflect.h2"
     auto autodiff_declaration_handler::traverse(cpp2::impl::in<meta::type_declaration> t) -> void{
         CPP2_UFCS(push_stack)((*cpp2::impl::assert_not_null(ctx)), t);
         autodiff_declaration_handler ad {ctx, t}; 
@@ -10141,17 +10317,17 @@ auto i{0};
         }
     }
 
-#line 6122 "reflect.h2"
+#line 6294 "reflect.h2"
     auto autodiff_declaration_handler::traverse(cpp2::impl::in<meta::parameter_declaration> t) -> void{
         CPP2_UFCS(error)(t, "AD: Do not know how to handle parameter_declaration: " + cpp2::to_string(CPP2_UFCS(to_string)(t)) + "");
     }
 
-#line 6127 "reflect.h2"
+#line 6299 "reflect.h2"
     auto autodiff_declaration_handler::traverse(cpp2::impl::in<meta::statement> stmt) -> void{
         CPP2_UFCS(error)(stmt, "AD: Do not know how to handle statement in declaration context: " + cpp2::to_string(CPP2_UFCS(to_string)(stmt)) + "");
     }
 
-#line 6133 "reflect.h2"
+#line 6305 "reflect.h2"
 auto autodiff(meta::type_declaration& t) -> void
 {
 
@@ -10334,7 +10510,7 @@ return expression_flags::none;
 [[nodiscard]] auto expression_flags::from_code(cpp2::impl::in<std::string_view> s) -> expression_flags{
 std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::move(str), "expression_flags::", "")); }
 
-#line 6225 "reflect.h2"
+#line 6397 "reflect.h2"
 //-----------------------------------------------------------------------
 //
 //  regex - creates regular expressions from members
@@ -10350,11 +10526,11 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov
 //  ```
 //
 
-#line 6241 "reflect.h2"
+#line 6413 "reflect.h2"
 //  Possible modifiers for a regular expression.
 //
 
-#line 6245 "reflect.h2"
+#line 6417 "reflect.h2"
                                   // mod: i
                                   // mod: m
                                   // mod: s
@@ -10362,116 +10538,116 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov
                                   // mod: x
                                   // mod: xx
 
-#line 6254 "reflect.h2"
+#line 6426 "reflect.h2"
 //  Tokens for regular expressions.
 //
 
 // Basic class for a regex token.
 //
 
-#line 6263 "reflect.h2"
+#line 6435 "reflect.h2"
     regex_token::regex_token(cpp2::impl::in<std::string> str)
         : string_rep{ str }{
 
-#line 6265 "reflect.h2"
+#line 6437 "reflect.h2"
     }
 
-#line 6267 "reflect.h2"
+#line 6439 "reflect.h2"
     regex_token::regex_token()
         : string_rep{ "" }{
 
-#line 6269 "reflect.h2"
+#line 6441 "reflect.h2"
     }
 
     //parse: (inout ctx: parse_context) -> token_ptr;
                                                                        // Generate the matching code.
                                                                        // Create a reverse token for look behind expressions.
 
-#line 6275 "reflect.h2"
+#line 6447 "reflect.h2"
     auto regex_token::add_groups([[maybe_unused]] std::set<int>& unnamed_param_2) const -> void{}// Adds all group indices to the set.
-#line 6276 "reflect.h2"
+#line 6448 "reflect.h2"
     [[nodiscard]] auto regex_token::to_string() const& -> std::string{return string_rep; }// Create a string representation.
-#line 6277 "reflect.h2"
+#line 6449 "reflect.h2"
     auto regex_token::set_string(cpp2::impl::in<std::string> s) & -> void{string_rep = s; }
 
     regex_token::~regex_token() noexcept{}// Set the string representation.
 
-#line 6292 "reflect.h2"
+#line 6464 "reflect.h2"
     regex_token_check::regex_token_check(cpp2::impl::in<std::string> str, cpp2::impl::in<std::string> check_)
         : regex_token{ str }
         , check{ check_ }{
 
-#line 6295 "reflect.h2"
+#line 6467 "reflect.h2"
     }
 
-#line 6297 "reflect.h2"
+#line 6469 "reflect.h2"
     auto regex_token_check::generate_code(generation_context& ctx) const -> void{
         ctx.add_check(check + "(" + ctx.match_parameters() + ")");
     }
 
-#line 6301 "reflect.h2"
+#line 6473 "reflect.h2"
     [[nodiscard]] auto regex_token_check::reverse() const -> token_ptr { return CPP2_UFCS_TEMPLATE(cpp2_new<regex_token_check>)(cpp2::shared, CPP2_UFCS(to_string)((*this)), (*this).check);  }
 
     regex_token_check::~regex_token_check() noexcept{}
 
-#line 6313 "reflect.h2"
+#line 6485 "reflect.h2"
     regex_token_code::regex_token_code(cpp2::impl::in<std::string> str, cpp2::impl::in<std::string> code_)
         : regex_token{ str }
         , code{ code_ }{
 
-#line 6316 "reflect.h2"
+#line 6488 "reflect.h2"
     }
 
-#line 6318 "reflect.h2"
+#line 6490 "reflect.h2"
     auto regex_token_code::generate_code(generation_context& ctx) const -> void{
         ctx.add(code);
     }
 
-#line 6322 "reflect.h2"
+#line 6494 "reflect.h2"
     [[nodiscard]] auto regex_token_code::reverse() const -> token_ptr { return CPP2_UFCS_TEMPLATE(cpp2_new<regex_token_code>)(cpp2::shared, CPP2_UFCS(to_string)((*this)), (*this).code);  }
 
     regex_token_code::~regex_token_code() noexcept{}
 
-#line 6332 "reflect.h2"
+#line 6504 "reflect.h2"
     regex_token_empty::regex_token_empty(cpp2::impl::in<std::string> str)
         : regex_token{ str }{
 
-#line 6334 "reflect.h2"
+#line 6506 "reflect.h2"
     }
 
-#line 6336 "reflect.h2"
+#line 6508 "reflect.h2"
     auto regex_token_empty::generate_code([[maybe_unused]] generation_context& unnamed_param_2) const -> void{
         // Nothing.
     }
 
-#line 6340 "reflect.h2"
+#line 6512 "reflect.h2"
     [[nodiscard]] auto regex_token_empty::reverse() const -> token_ptr { return CPP2_UFCS_TEMPLATE(cpp2_new<regex_token_empty>)(cpp2::shared, CPP2_UFCS(to_string)((*this)));  }
 
     regex_token_empty::~regex_token_empty() noexcept{}
 
-#line 6352 "reflect.h2"
+#line 6524 "reflect.h2"
     regex_token_list::regex_token_list(cpp2::impl::in<token_vec> t)
         : regex_token{ gen_string(t) }
         , tokens{ t }{
 
-#line 6355 "reflect.h2"
+#line 6527 "reflect.h2"
     }
 
-#line 6357 "reflect.h2"
+#line 6529 "reflect.h2"
     auto regex_token_list::generate_code(generation_context& ctx) const -> void{
         for ( auto const& token : tokens ) {
             (*cpp2::impl::assert_not_null(token)).generate_code(ctx);
         }
     }
 
-#line 6363 "reflect.h2"
+#line 6535 "reflect.h2"
     auto regex_token_list::add_groups(std::set<int>& groups) const -> void{
         for ( auto const& token : tokens ) {
             (*cpp2::impl::assert_not_null(token)).add_groups(groups);
         }
     }
 
-#line 6369 "reflect.h2"
+#line 6541 "reflect.h2"
     [[nodiscard]] auto regex_token_list::gen_string(cpp2::impl::in<token_vec> vec) -> std::string{
         std::string r {""}; 
         for ( auto const& token : vec ) {
@@ -10480,7 +10656,7 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov
         return r; 
     }
 
-#line 6377 "reflect.h2"
+#line 6549 "reflect.h2"
     [[nodiscard]] auto regex_token_list::reverse() const -> token_ptr{
         int s {cpp2::unchecked_narrow<int>(tokens.size())}; 
 
@@ -10496,7 +10672,7 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov
 
     regex_token_list::~regex_token_list() noexcept{}
 
-#line 6405 "reflect.h2"
+#line 6577 "reflect.h2"
     auto parse_context_group_state::next_alternative() & -> void{
         token_vec new_list {}; 
         std::swap(new_list, cur_match_list);
@@ -10504,14 +10680,14 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov
         static_cast<void>(alternate_match_lists.insert(alternate_match_lists.end(), CPP2_UFCS_TEMPLATE(cpp2_new<regex_token_list>)(cpp2::shared, cpp2::move(new_list))));
     }
 
-#line 6413 "reflect.h2"
+#line 6585 "reflect.h2"
     auto parse_context_group_state::swap(parse_context_group_state& t) & -> void{// NOLINT(performance-noexcept-swap)
         std::swap(cur_match_list, t.cur_match_list);
         std::swap(alternate_match_lists, t.alternate_match_lists);
         std::swap(modifiers, t.modifiers);
     }
 
-#line 6420 "reflect.h2"
+#line 6592 "reflect.h2"
     [[nodiscard]] auto parse_context_group_state::get_as_token() & -> token_ptr{
         if (alternate_match_lists.empty()) {
             post_process_list(cur_match_list);
@@ -10523,15 +10699,15 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov
         }
     }
 
-#line 6432 "reflect.h2"
+#line 6604 "reflect.h2"
     auto parse_context_group_state::add(cpp2::impl::in<token_ptr> token) & -> void{
         cur_match_list.push_back(token);
     }
 
-#line 6437 "reflect.h2"
+#line 6609 "reflect.h2"
     [[nodiscard]] auto parse_context_group_state::empty() const& -> bool { return cur_match_list.empty();  }
 
-#line 6441 "reflect.h2"
+#line 6613 "reflect.h2"
     auto parse_context_group_state::post_process_list(token_vec& list) -> void{
         // Merge all characters
         auto merge_pos {list.begin()}; 
@@ -10552,7 +10728,7 @@ std::string str {s}; return from_string(cpp2::string_util::replace_all(cpp2::mov
                                                                                               , modifiers{ modifiers_ }{}
 parse_context_group_state::parse_context_group_state(){}
 
-#line 6467 "reflect.h2"
+#line 6639 "reflect.h2"
     [[nodiscard]] auto parse_context_branch_reset_state::next() & -> int{
         auto g {cur_group}; 
         cur_group += 1;
@@ -10561,20 +10737,20 @@ parse_context_group_state::parse_context_group_state(){}
         return g; 
     }
 
-#line 6476 "reflect.h2"
+#line 6648 "reflect.h2"
     auto parse_context_branch_reset_state::set_next(cpp2::impl::in<int> g) & -> void{
         cur_group = g;
         max_group = max(max_group, g);
     }
 
-#line 6482 "reflect.h2"
+#line 6654 "reflect.h2"
     auto parse_context_branch_reset_state::next_alternative() & -> void{
         if (is_active) {
             cur_group = from;
         }
     }
 
-#line 6489 "reflect.h2"
+#line 6661 "reflect.h2"
     auto parse_context_branch_reset_state::set_active_reset(cpp2::impl::in<int> restart) & -> void{
         is_active = true;
         cur_group = restart;
@@ -10589,16 +10765,16 @@ parse_context_group_state::parse_context_group_state(){}
                                                                                     , from{ from_ }{}
 parse_context_branch_reset_state::parse_context_branch_reset_state(){}
 
-#line 6519 "reflect.h2"
+#line 6691 "reflect.h2"
     parse_context::parse_context(cpp2::impl::in<std::string_view> r, auto const& e)
         : regex{ r }
         , root{ CPP2_UFCS_TEMPLATE_NONLOCAL(cpp2_new<regex_token_empty>)(cpp2::shared, "") }
         , error_out{ e }{
 
-#line 6523 "reflect.h2"
+#line 6695 "reflect.h2"
     }
 
-#line 6529 "reflect.h2"
+#line 6701 "reflect.h2"
     [[nodiscard]] auto parse_context::start_group() & -> parse_context_group_state
     {
         parse_context_group_state old_state {}; 
@@ -10608,7 +10784,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return old_state; 
     }
 
-#line 6539 "reflect.h2"
+#line 6711 "reflect.h2"
     [[nodiscard]] auto parse_context::end_group(cpp2::impl::in<parse_context_group_state> old_state) & -> token_ptr
     {
         auto inner {cur_group_state.get_as_token()}; 
@@ -10616,17 +10792,17 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return inner; 
     }
 
-#line 6546 "reflect.h2"
+#line 6718 "reflect.h2"
     [[nodiscard]] auto parse_context::get_modifiers() const& -> expression_flags{
         return cur_group_state.modifiers; 
     }
 
-#line 6550 "reflect.h2"
+#line 6722 "reflect.h2"
     auto parse_context::set_modifiers(cpp2::impl::in<expression_flags> mod) & -> void{
         cur_group_state.modifiers = mod;
     }
 
-#line 6557 "reflect.h2"
+#line 6729 "reflect.h2"
     [[nodiscard]] auto parse_context::branch_reset_new_state() & -> parse_context_branch_reset_state
     {
         parse_context_branch_reset_state old_state {}; 
@@ -10636,7 +10812,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return old_state; 
     }
 
-#line 6566 "reflect.h2"
+#line 6738 "reflect.h2"
     auto parse_context::branch_reset_restore_state(cpp2::impl::in<parse_context_branch_reset_state> old_state) & -> void
     {
         auto max_group {cur_branch_reset_state.max_group}; 
@@ -10644,24 +10820,24 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         cur_branch_reset_state.set_next(cpp2::move(max_group));
     }
 
-#line 6573 "reflect.h2"
+#line 6745 "reflect.h2"
     auto parse_context::next_alternative() & -> void
     {
         cur_group_state.next_alternative();
         cur_branch_reset_state.next_alternative();
     }
 
-#line 6581 "reflect.h2"
+#line 6753 "reflect.h2"
     auto parse_context::add_token(cpp2::impl::in<token_ptr> token) & -> void{
         cur_group_state.add(token);
     }
 
-#line 6585 "reflect.h2"
+#line 6757 "reflect.h2"
     [[nodiscard]] auto parse_context::has_token() const& -> bool{
         return !(cur_group_state.empty()); 
     }
 
-#line 6589 "reflect.h2"
+#line 6761 "reflect.h2"
     [[nodiscard]] auto parse_context::pop_token() & -> token_ptr
     {
         token_ptr r {nullptr}; 
@@ -10673,22 +10849,22 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return r; 
     }
 
-#line 6600 "reflect.h2"
+#line 6772 "reflect.h2"
     [[nodiscard]] auto parse_context::get_as_token() & -> token_ptr{
         return root; 
     }
 
-#line 6606 "reflect.h2"
+#line 6778 "reflect.h2"
     [[nodiscard]] auto parse_context::get_cur_group() const& -> int{
         return cur_branch_reset_state.cur_group; 
     }
 
-#line 6610 "reflect.h2"
+#line 6782 "reflect.h2"
     [[nodiscard]] auto parse_context::next_group() & -> int{
         return cur_branch_reset_state.next(); 
     }
 
-#line 6614 "reflect.h2"
+#line 6786 "reflect.h2"
     auto parse_context::set_named_group(cpp2::impl::in<std::string> name, cpp2::impl::in<int> id) & -> void
     {
         if (!(named_groups.contains(name))) {// Redefinition of group name is not an error. The left most one is retained.
@@ -10696,7 +10872,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         }
     }
 
-#line 6621 "reflect.h2"
+#line 6793 "reflect.h2"
     [[nodiscard]] auto parse_context::get_named_group(cpp2::impl::in<std::string> name) const& -> int
     {
         auto iter {named_groups.find(name)}; 
@@ -10708,10 +10884,10 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         }
     }
 
-#line 6634 "reflect.h2"
+#line 6806 "reflect.h2"
     [[nodiscard]] auto parse_context::current() const& -> char{return CPP2_ASSERT_IN_BOUNDS(regex, pos); }
 
-#line 6637 "reflect.h2"
+#line 6809 "reflect.h2"
     [[nodiscard]] auto parse_context::get_next_position(cpp2::impl::in<bool> in_class, cpp2::impl::in<bool> no_skip) const& -> size_t
     {
         auto perl_syntax {false}; 
@@ -10751,7 +10927,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return cur; 
     }
 
-#line 6677 "reflect.h2"
+#line 6849 "reflect.h2"
     [[nodiscard]] auto parse_context::next_impl(cpp2::impl::in<bool> in_class, cpp2::impl::in<bool> no_skip) & -> bool
     {
         pos = get_next_position(in_class, no_skip);
@@ -10763,14 +10939,14 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         }
     }
 
-#line 6688 "reflect.h2"
+#line 6860 "reflect.h2"
     [[nodiscard]] auto parse_context::next() & -> decltype(auto) { return next_impl(false, false); }
-#line 6689 "reflect.h2"
+#line 6861 "reflect.h2"
     [[nodiscard]] auto parse_context::next_in_class() & -> decltype(auto) { return next_impl(true, false);  }
-#line 6690 "reflect.h2"
+#line 6862 "reflect.h2"
     [[nodiscard]] auto parse_context::next_no_skip() & -> decltype(auto) { return next_impl(false, true); }
 
-#line 6692 "reflect.h2"
+#line 6864 "reflect.h2"
     [[nodiscard]] auto parse_context::next_n(cpp2::impl::in<int> n) & -> bool{
         auto r {true}; 
         auto cur {0}; 
@@ -10780,10 +10956,10 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return r; 
     }
 
-#line 6701 "reflect.h2"
+#line 6873 "reflect.h2"
     [[nodiscard]] auto parse_context::has_next() const& -> bool{return cpp2::impl::cmp_less(pos,regex.size()); }
 
-#line 6703 "reflect.h2"
+#line 6875 "reflect.h2"
     [[nodiscard]] auto parse_context::grab_until_impl(cpp2::impl::in<std::string> e, cpp2::impl::out<std::string> r, cpp2::impl::in<bool> any) & -> bool
     {
         auto end {pos}; // NOLINT(clang-analyzer-deadcode.DeadStores)
@@ -10805,14 +10981,14 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         }
     }
 
-#line 6724 "reflect.h2"
+#line 6896 "reflect.h2"
     [[nodiscard]] auto parse_context::grab_until(cpp2::impl::in<std::string> e, cpp2::impl::out<std::string> r) & -> decltype(auto) { return grab_until_impl(e, cpp2::impl::out(&r), false); }
-#line 6725 "reflect.h2"
+#line 6897 "reflect.h2"
     [[nodiscard]] auto parse_context::grab_until(cpp2::impl::in<char> e, cpp2::impl::out<std::string> r) & -> decltype(auto) { return grab_until_impl(std::string(1, e), cpp2::impl::out(&r), false); }
-#line 6726 "reflect.h2"
+#line 6898 "reflect.h2"
     [[nodiscard]] auto parse_context::grab_until_one_of(cpp2::impl::in<std::string> e, cpp2::impl::out<std::string> r) & -> decltype(auto) { return grab_until_impl(e, cpp2::impl::out(&r), true);  }
 
-#line 6728 "reflect.h2"
+#line 6900 "reflect.h2"
     [[nodiscard]] auto parse_context::grab_n(cpp2::impl::in<int> n, cpp2::impl::out<std::string> r) & -> bool
     {
         if (cpp2::impl::cmp_less_eq(pos + cpp2::impl::as_<size_t>(n),regex.size())) {
@@ -10826,7 +11002,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         }
     }
 
-#line 6741 "reflect.h2"
+#line 6913 "reflect.h2"
     [[nodiscard]] auto parse_context::grab_number() & -> std::string
     {
         auto start {pos}; 
@@ -10848,7 +11024,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return cpp2::move(r.value()); 
     }
 
-#line 6762 "reflect.h2"
+#line 6934 "reflect.h2"
     [[nodiscard]] auto parse_context::peek_impl(cpp2::impl::in<bool> in_class) const& -> char{
         auto next_pos {get_next_position(in_class, false)}; 
         if (cpp2::impl::cmp_less(next_pos,regex.size())) {
@@ -10859,12 +11035,12 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         }
     }
 
-#line 6772 "reflect.h2"
+#line 6944 "reflect.h2"
     [[nodiscard]] auto parse_context::peek() const& -> decltype(auto) { return peek_impl(false); }
-#line 6773 "reflect.h2"
+#line 6945 "reflect.h2"
     [[nodiscard]] auto parse_context::peek_in_class() const& -> decltype(auto) { return peek_impl(true);  }
 
-#line 6778 "reflect.h2"
+#line 6950 "reflect.h2"
     [[nodiscard]] auto parse_context::parser_group_modifiers(cpp2::impl::in<std::string> change_str, expression_flags& parser_modifiers) & -> bool
     {
         auto is_negative {false}; 
@@ -10919,7 +11095,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return true; 
     }
 
-#line 6832 "reflect.h2"
+#line 7004 "reflect.h2"
     [[nodiscard]] auto parse_context::parse_until(cpp2::impl::in<char> term) & -> bool{
         token_ptr cur_token {}; 
 
@@ -10959,7 +11135,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return true; 
     }
 
-#line 6871 "reflect.h2"
+#line 7043 "reflect.h2"
     [[nodiscard]] auto parse_context::parse(cpp2::impl::in<std::string> modifiers) & -> bool
     {
 
@@ -10975,21 +11151,21 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         return r; 
     }
 
-#line 6888 "reflect.h2"
+#line 7060 "reflect.h2"
     [[nodiscard]] auto parse_context::get_pos() const& -> decltype(auto) { return pos; }
-#line 6889 "reflect.h2"
+#line 7061 "reflect.h2"
     [[nodiscard]] auto parse_context::get_range(cpp2::impl::in<size_t> start, cpp2::impl::in<size_t> end) const& -> decltype(auto) { return std::string(regex.substr(start, end - start + 1));  }
-#line 6890 "reflect.h2"
+#line 7062 "reflect.h2"
     [[nodiscard]] auto parse_context::valid() const& -> bool{return has_next() && !(has_error); }
 
-#line 6892 "reflect.h2"
+#line 7064 "reflect.h2"
     [[nodiscard]] auto parse_context::error(cpp2::impl::in<std::string> err) & -> token_ptr{
         has_error = true;
         error_out("Error during parsing of regex '" + cpp2::to_string(regex) + "' at position '" + cpp2::to_string(pos) + "': " + cpp2::to_string(err) + "");
         return nullptr; 
     }
 
-#line 6907 "reflect.h2"
+#line 7079 "reflect.h2"
     auto generation_function_context::add_tabs(cpp2::impl::in<int> c) & -> void{
         int i {0}; 
         for( ; cpp2::impl::cmp_less(i,c); i += 1 ) {
@@ -10997,7 +11173,7 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
         }
     }
 
-#line 6914 "reflect.h2"
+#line 7086 "reflect.h2"
     auto generation_function_context::remove_tabs(cpp2::impl::in<int> c) & -> void{
         tabs = tabs.substr(0, (cpp2::impl::as_<size_t>(c)) * 2);
     }
@@ -11007,22 +11183,22 @@ parse_context_branch_reset_state::parse_context_branch_reset_state(){}
                                                        , tabs{ tabs_ }{}
 generation_function_context::generation_function_context(){}
 
-#line 6932 "reflect.h2"
+#line 7104 "reflect.h2"
     [[nodiscard]] auto generation_context::match_parameters() const& -> std::string{return "r.pos, ctx"; }
 
-#line 6937 "reflect.h2"
+#line 7109 "reflect.h2"
     auto generation_context::add(cpp2::impl::in<std::string> s) & -> void{
         auto cur {get_current()}; 
         (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + cpp2::to_string(s) + "\n";
     }
 
-#line 6943 "reflect.h2"
+#line 7115 "reflect.h2"
     auto generation_context::add_check(cpp2::impl::in<std::string> check) & -> void{
         auto cur {get_current()}; 
         (*cpp2::impl::assert_not_null(cur)).code += "" + cpp2::to_string((*cpp2::impl::assert_not_null(cur)).tabs) + "if !cpp2::regex::" + cpp2::to_string(check) + " { r.matched = false; break; }\n";
     }
 
-#line 6949 "reflect.h2"
+#line 7121 "reflect.h2"
     auto generation_context::add_statefull(cpp2::impl::in<std::string> next_func, cpp2::impl::in<std::string> check) & -> void
     {
         end_func_statefull(check);
@@ -11031,7 +11207,7 @@ generation_function_context::generation_function_context(){}
         start_func_named(cpp2::move(name));
     }
 
-#line 6957 "reflect.h2"
+#line 7129 "reflect.h2"
     auto generation_context::start_func_named(cpp2::impl::in<std::string> name) & -> void
     {
         auto cur {new_context()}; 
@@ -11043,7 +11219,7 @@ generation_function_context::generation_function_context(){}
         (*cpp2::impl::assert_not_null(cpp2::move(cur))).add_tabs(3);
     }
 
-#line 6968 "reflect.h2"
+#line 7140 "reflect.h2"
     [[nodiscard]] auto generation_context::start_func() & -> std::string
     {
         auto name {gen_func_name()}; 
@@ -11051,7 +11227,7 @@ generation_function_context::generation_function_context(){}
         return cpp2::move(name) + "()"; 
     }
 
-#line 6975 "reflect.h2"
+#line 7147 "reflect.h2"
     auto generation_context::end_func_statefull(cpp2::impl::in<std::string> s) & -> void
     {
         auto cur {get_current()}; 
@@ -11072,7 +11248,7 @@ generation_function_context::generation_function_context(){}
         finish_context();
     }
 
-#line 6996 "reflect.h2"
+#line 7168 "reflect.h2"
     [[nodiscard]] auto generation_context::generate_func(cpp2::impl::in<token_ptr> token) & -> std::string
     {
         auto name {start_func()}; 
@@ -11082,7 +11258,7 @@ generation_function_context::generation_function_context(){}
         return name; 
     }
 
-#line 7006 "reflect.h2"
+#line 7178 "reflect.h2"
     [[nodiscard]] auto generation_context::generate_reset(cpp2::impl::in<std::set<int>> groups) & -> std::string
     {
         if (groups.empty()) {
@@ -11105,33 +11281,33 @@ generation_function_context::generation_function_context(){}
         return cpp2::move(name) + "()"; 
     }
 
-#line 7030 "reflect.h2"
+#line 7202 "reflect.h2"
     [[nodiscard]] auto generation_context::gen_func_name() & -> std::string{
         auto cur_id {matcher_func}; 
         matcher_func += 1;
         return "func_" + cpp2::to_string(cpp2::move(cur_id)) + ""; 
     }
 
-#line 7036 "reflect.h2"
+#line 7208 "reflect.h2"
     [[nodiscard]] auto generation_context::next_func_name() & -> std::string{
         return gen_func_name() + "()"; 
     }
 
-#line 7040 "reflect.h2"
+#line 7212 "reflect.h2"
     [[nodiscard]] auto generation_context::gen_reset_func_name() & -> std::string{
         auto cur_id {reset_func}; 
         reset_func += 1;
         return "reset_" + cpp2::to_string(cpp2::move(cur_id)) + ""; 
     }
 
-#line 7046 "reflect.h2"
+#line 7218 "reflect.h2"
     [[nodiscard]] auto generation_context::gen_temp() & -> std::string{
         auto cur_id {temp_name}; 
         temp_name += 1;
         return "tmp_" + cpp2::to_string(cpp2::move(cur_id)) + ""; 
     }
 
-#line 7054 "reflect.h2"
+#line 7226 "reflect.h2"
     [[nodiscard]] auto generation_context::new_context() & -> generation_function_context*{
         gen_stack.push_back(generation_function_context());
         auto cur {get_current()}; 
@@ -11140,7 +11316,7 @@ generation_function_context::generation_function_context(){}
         return cur; 
     }
 
-#line 7062 "reflect.h2"
+#line 7234 "reflect.h2"
     auto generation_context::finish_context() & -> void{
         auto cur {get_current()}; 
         auto base {get_base()}; 
@@ -11149,22 +11325,22 @@ generation_function_context::generation_function_context(){}
         gen_stack.pop_back();
     }
 
-#line 7072 "reflect.h2"
+#line 7244 "reflect.h2"
     [[nodiscard]] auto generation_context::get_current() & -> generation_function_context*{
         return &gen_stack.back(); 
     }
 
-#line 7076 "reflect.h2"
+#line 7248 "reflect.h2"
     [[nodiscard]] auto generation_context::get_base() & -> generation_function_context*{
         return &CPP2_ASSERT_IN_BOUNDS_LITERAL(gen_stack, 0); 
     }
 
-#line 7080 "reflect.h2"
+#line 7252 "reflect.h2"
     [[nodiscard]] auto generation_context::get_entry_func() const& -> std::string{
         return entry_func; 
     }
 
-#line 7084 "reflect.h2"
+#line 7256 "reflect.h2"
     [[nodiscard]] auto generation_context::create_named_group_lookup(cpp2::impl::in<std::map<std::string,int>> named_groups) const& -> std::string
     {
         std::string res {"get_named_group_index: (name) -> int = {\n"}; 
@@ -11188,18 +11364,18 @@ generation_function_context::generation_function_context(){}
         return res; 
     }
 
-#line 7109 "reflect.h2"
+#line 7281 "reflect.h2"
     [[nodiscard]] auto generation_context::run(cpp2::impl::in<token_ptr> token) & -> std::string{
         entry_func = generate_func(token);
 
         return (*cpp2::impl::assert_not_null(get_base())).code; 
     }
 
-#line 7124 "reflect.h2"
+#line 7296 "reflect.h2"
     alternative_token::alternative_token()
                             : regex_token_empty{ "" }{}
 
-#line 7126 "reflect.h2"
+#line 7298 "reflect.h2"
     [[nodiscard]] auto alternative_token::parse(parse_context& ctx) -> token_ptr{
         if (ctx.current() != '|') {return nullptr; }
 
@@ -11210,15 +11386,15 @@ generation_function_context::generation_function_context(){}
 
     alternative_token::~alternative_token() noexcept{}
 
-#line 7141 "reflect.h2"
+#line 7313 "reflect.h2"
     alternative_token_gen::alternative_token_gen(cpp2::impl::in<token_vec> a)
         : regex_token{ gen_string(a) }
         , alternatives{ a }{
 
-#line 7144 "reflect.h2"
+#line 7316 "reflect.h2"
     }
 
-#line 7146 "reflect.h2"
+#line 7318 "reflect.h2"
     auto alternative_token_gen::generate_code(generation_context& ctx) const -> void
     {
         std::string functions {""}; 
@@ -11236,7 +11412,7 @@ generation_function_context::generation_function_context(){}
         ctx.add_statefull(next_name, "cpp2::regex::alternative_token_matcher<char>::match(" + cpp2::to_string(ctx.match_parameters()) + ", other, " + cpp2::to_string(next_name) + " " + cpp2::to_string(cpp2::move(functions)) + ")");
     }
 
-#line 7163 "reflect.h2"
+#line 7335 "reflect.h2"
     auto alternative_token_gen::add_groups(std::set<int>& groups) const -> void
     {
         for ( auto const& cur : alternatives ) {
@@ -11244,7 +11420,7 @@ generation_function_context::generation_function_context(){}
         }
     }
 
-#line 7170 "reflect.h2"
+#line 7342 "reflect.h2"
     [[nodiscard]] auto alternative_token_gen::gen_string(cpp2::impl::in<token_vec> a) -> std::string
     {
         std::string r {""}; 
@@ -11258,7 +11434,7 @@ generation_function_context::generation_function_context(){}
         return r; 
     }
 
-#line 7183 "reflect.h2"
+#line 7355 "reflect.h2"
     [[nodiscard]] auto alternative_token_gen::reverse() const -> token_ptr{
         int s {cpp2::unchecked_narrow<int>(alternatives.size())}; 
 
@@ -11274,14 +11450,14 @@ generation_function_context::generation_function_context(){}
 
     alternative_token_gen::~alternative_token_gen() noexcept{}
 
-#line 7204 "reflect.h2"
+#line 7376 "reflect.h2"
     any_token::any_token(cpp2::impl::in<bool> single_line)
         : regex_token_check{ ".", "any_token_matcher<char, " + cpp2::to_string(single_line) + ">" }{
 
-#line 7206 "reflect.h2"
+#line 7378 "reflect.h2"
     }
 
-#line 7208 "reflect.h2"
+#line 7380 "reflect.h2"
     [[nodiscard]] auto any_token::parse(parse_context& ctx) -> token_ptr{
         if ('.' != ctx.current()) {return nullptr; }
 
@@ -11290,11 +11466,11 @@ generation_function_context::generation_function_context(){}
 
     any_token::~any_token() noexcept{}
 
-#line 7223 "reflect.h2"
+#line 7395 "reflect.h2"
     atomic_group_token::atomic_group_token()
                              : regex_token{ "" }{}
 
-#line 7225 "reflect.h2"
+#line 7397 "reflect.h2"
     [[nodiscard]] auto atomic_group_token::reverse() const -> token_ptr{
         auto r {CPP2_UFCS_TEMPLATE(cpp2_new<atomic_group_token>)(cpp2::shared)}; 
         (*cpp2::impl::assert_not_null(r)).inner_token = CPP2_UFCS(reverse)((*cpp2::impl::assert_not_null(inner_token)));
@@ -11302,7 +11478,7 @@ generation_function_context::generation_function_context(){}
         return r; 
     }
 
-#line 7232 "reflect.h2"
+#line 7404 "reflect.h2"
     auto atomic_group_token::generate_code(generation_context& ctx) const -> void
     {
         auto inner_name {ctx.generate_func(inner_token)}; 
@@ -11311,37 +11487,37 @@ generation_function_context::generation_function_context(){}
         ctx.add_statefull(next_name, "cpp2::regex::atomic_group_matcher<char>(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ", other, " + cpp2::to_string(next_name) + ")");
     }
 
-#line 7240 "reflect.h2"
+#line 7412 "reflect.h2"
     auto atomic_group_token::add_groups(std::set<int>& groups) const -> void{
         (*cpp2::impl::assert_not_null(inner_token)).add_groups(groups);
     }
 
     atomic_group_token::~atomic_group_token() noexcept{}
 
-#line 7254 "reflect.h2"
+#line 7426 "reflect.h2"
     char_token::char_token(cpp2::impl::in<char> t, cpp2::impl::in<bool> ignore_case_)
         : regex_token{ std::string(1, t) }
         , token{ t }
         , ignore_case{ ignore_case_ }{
 
-#line 7258 "reflect.h2"
+#line 7430 "reflect.h2"
     }
 
-#line 7260 "reflect.h2"
+#line 7432 "reflect.h2"
     char_token::char_token(cpp2::impl::in<std::string> t, cpp2::impl::in<bool> ignore_case_)
         : regex_token{ t }
         , token{ t }
         , ignore_case{ ignore_case_ }{
 
-#line 7264 "reflect.h2"
+#line 7436 "reflect.h2"
     }
 
-#line 7266 "reflect.h2"
+#line 7438 "reflect.h2"
     [[nodiscard]] auto char_token::parse(parse_context& ctx) -> token_ptr{
         return CPP2_UFCS_TEMPLATE(cpp2_new<char_token>)(cpp2::shared, ctx.current(), ctx.get_modifiers().has(expression_flags::case_insensitive)); 
     }
 
-#line 7270 "reflect.h2"
+#line 7442 "reflect.h2"
     auto char_token::generate_code(generation_context& ctx) const -> void
     {
         if (ignore_case) {
@@ -11350,14 +11526,14 @@ generation_function_context::generation_function_context(){}
 {
 size_t i{0};
 
-#line 7276 "reflect.h2"
+#line 7448 "reflect.h2"
             for( ; cpp2::impl::cmp_less(i,token.size()); i += 1 ) {
                 CPP2_ASSERT_IN_BOUNDS(lower, i) = string_util::safe_tolower(CPP2_ASSERT_IN_BOUNDS(token, i));
                 CPP2_ASSERT_IN_BOUNDS(upper, i) = string_util::safe_toupper(CPP2_ASSERT_IN_BOUNDS(token, i));
             }
 }
 
-#line 7281 "reflect.h2"
+#line 7453 "reflect.h2"
             if (upper != lower) {
                 gen_case_insensitive(cpp2::move(lower), cpp2::move(upper), ctx);
             }
@@ -11370,7 +11546,7 @@ size_t i{0};
         }
     }
 
-#line 7293 "reflect.h2"
+#line 7465 "reflect.h2"
     auto char_token::gen_case_insensitive(cpp2::impl::in<std::string> lower, cpp2::impl::in<std::string> upper, generation_context& ctx) const& -> void
     {
         std::string name {"str_" + cpp2::to_string(ctx.gen_temp()) + ""}; 
@@ -11392,7 +11568,7 @@ size_t i{0};
         ctx.add("else { break; }");
     }
 
-#line 7314 "reflect.h2"
+#line 7486 "reflect.h2"
     auto char_token::gen_case_sensitive(generation_context& ctx) const& -> void
     {
         std::string name {"str_" + cpp2::to_string(ctx.gen_temp()) + ""}; 
@@ -11411,7 +11587,7 @@ size_t i{0};
         ctx.add("else { break; }");
     }
 
-#line 7332 "reflect.h2"
+#line 7504 "reflect.h2"
     [[nodiscard]] auto char_token::add_escapes(std::string str) const& -> std::string
     {
         str = string_util::replace_all(str, "\\", "\\\\");
@@ -11427,14 +11603,14 @@ size_t i{0};
         return cpp2::move(str); 
     }
 
-#line 7347 "reflect.h2"
+#line 7519 "reflect.h2"
     [[nodiscard]] auto char_token::reverse() const -> token_ptr{
         std::string reverse_str {token}; 
         std::reverse(reverse_str.begin(), reverse_str.end());
         return CPP2_UFCS_TEMPLATE(cpp2_new<char_token>)(cpp2::shared, cpp2::move(reverse_str), ignore_case); 
     }
 
-#line 7353 "reflect.h2"
+#line 7525 "reflect.h2"
     auto char_token::append(char_token const& that) & -> void{
         (*this).token += that.token;
         (*this).string_rep += that.string_rep;
@@ -11442,19 +11618,19 @@ size_t i{0};
 
     char_token::~char_token() noexcept{}
 
-#line 7370 "reflect.h2"
+#line 7542 "reflect.h2"
     class_token::class_token(cpp2::impl::in<bool> negate_, cpp2::impl::in<bool> case_insensitive_, cpp2::impl::in<std::string> class_str_, cpp2::impl::in<std::string> str)
         : regex_token{ str }
         , negate{ negate_ }
         , case_insensitive{ case_insensitive_ }
         , class_str{ class_str_ }
-#line 7371 "reflect.h2"
+#line 7543 "reflect.h2"
     {
 
-#line 7376 "reflect.h2"
+#line 7548 "reflect.h2"
     }
 
-#line 7379 "reflect.h2"
+#line 7551 "reflect.h2"
     [[nodiscard]] auto class_token::parse(parse_context& ctx) -> token_ptr
     {
         if (ctx.current() != '[') {return nullptr; }
@@ -11580,7 +11756,7 @@ size_t i{0};
             ); 
     }
 
-#line 7504 "reflect.h2"
+#line 7676 "reflect.h2"
     [[nodiscard]] auto class_token::reverse() const -> token_ptr{
         return CPP2_UFCS_TEMPLATE(cpp2_new<class_token>)(cpp2::shared, 
             negate, 
@@ -11590,13 +11766,13 @@ size_t i{0};
             ); 
     }
 
-#line 7513 "reflect.h2"
+#line 7685 "reflect.h2"
     auto class_token::generate_code(generation_context& ctx) const -> void
     {
         ctx.add_check("class_token_matcher<char, " + cpp2::to_string(negate) + ", " + cpp2::to_string(case_insensitive) + ", " + cpp2::to_string(class_str) + ">::match(" + cpp2::to_string(ctx.match_parameters()) + ")");
     }
 
-#line 7518 "reflect.h2"
+#line 7690 "reflect.h2"
     [[nodiscard]] auto class_token::create_matcher(cpp2::impl::in<std::string> name, cpp2::impl::in<std::string> template_arguments) -> std::string
     {
         auto sep {", "}; 
@@ -11607,12 +11783,12 @@ size_t i{0};
 
     class_token::~class_token() noexcept{}
 
-#line 7530 "reflect.h2"
+#line 7702 "reflect.h2"
 [[nodiscard]] auto escape_token_parse(parse_context& ctx) -> token_ptr
 {
     if (ctx.current() != '\\') {return nullptr; }
 
-#line 7535 "reflect.h2"
+#line 7707 "reflect.h2"
     if (std::string::npos == std::string("afenrt^.[]()*{}?+|\\").find(ctx.peek())) {
         return nullptr; 
     }
@@ -11646,7 +11822,7 @@ size_t i{0};
 
 }
 
-#line 7571 "reflect.h2"
+#line 7743 "reflect.h2"
 [[nodiscard]] auto global_group_reset_token_parse(parse_context& ctx) -> token_ptr
 {
     if (!((ctx.current() == '\\' && ctx.peek() == 'K'))) {return nullptr; }
@@ -11655,19 +11831,19 @@ size_t i{0};
     return CPP2_UFCS_TEMPLATE(cpp2_new<regex_token_code>)(cpp2::shared, "\\K", "ctx..set_group_start(0, r.pos);"); 
 }
 
-#line 7594 "reflect.h2"
+#line 7766 "reflect.h2"
     group_ref_token::group_ref_token(cpp2::impl::in<int> id_, cpp2::impl::in<bool> case_insensitive_, cpp2::impl::in<bool> reverse_, cpp2::impl::in<std::string> str)
         : regex_token{ str }
         , id{ id_ }
         , case_insensitive{ case_insensitive_ }
         , reverse_eval{ reverse_ }
-#line 7595 "reflect.h2"
+#line 7767 "reflect.h2"
     {
 
-#line 7600 "reflect.h2"
+#line 7772 "reflect.h2"
     }
 
-#line 7602 "reflect.h2"
+#line 7774 "reflect.h2"
     [[nodiscard]] auto group_ref_token::parse(parse_context& ctx) -> token_ptr
     {
         if (ctx.current() != '\\') {return nullptr; }
@@ -11769,19 +11945,19 @@ size_t i{0};
         return CPP2_UFCS_TEMPLATE(cpp2_new<group_ref_token>)(cpp2::shared, cpp2::move(group_id), ctx.get_modifiers().has(expression_flags::case_insensitive), false, cpp2::move(str)); 
     }
 
-#line 7703 "reflect.h2"
+#line 7875 "reflect.h2"
     [[nodiscard]] auto group_ref_token::reverse() const -> token_ptr{
         return CPP2_UFCS_TEMPLATE(cpp2_new<group_ref_token>)(cpp2::shared, id, case_insensitive, !(reverse_eval), to_string()); 
     }
 
-#line 7707 "reflect.h2"
+#line 7879 "reflect.h2"
     auto group_ref_token::generate_code(generation_context& ctx) const -> void{
         ctx.add_check("group_ref_token_matcher<char, " + cpp2::to_string(id) + ", " + cpp2::to_string(case_insensitive) + ", " + cpp2::to_string(reverse_eval) + ">(" + cpp2::to_string(ctx.match_parameters()) + ")");
     }
 
     group_ref_token::~group_ref_token() noexcept{}
 
-#line 7731 "reflect.h2"
+#line 7903 "reflect.h2"
     [[nodiscard]] auto group_token::parse_lookahead_lookbehind(parse_context& ctx, cpp2::impl::in<std::string> syntax, cpp2::impl::in<bool> lookahead, cpp2::impl::in<bool> positive) -> token_ptr
     {
         static_cast<void>(ctx.next());// Skip last token defining the syntax
@@ -11800,7 +11976,7 @@ size_t i{0};
         return r; 
     }
 
-#line 7749 "reflect.h2"
+#line 7921 "reflect.h2"
     [[nodiscard]] auto group_token::parse_atomic_pattern(parse_context& ctx, cpp2::impl::in<std::string> syntax) -> token_ptr
     {
         static_cast<void>(ctx.next());// Skip last token defining the syntax
@@ -11815,7 +11991,7 @@ size_t i{0};
         return r; 
     }
 
-#line 7763 "reflect.h2"
+#line 7935 "reflect.h2"
     [[nodiscard]] auto group_token::parse(parse_context& ctx) -> token_ptr
     {
         if (ctx.current() != '(') {return nullptr; }
@@ -11975,7 +12151,7 @@ size_t i{0};
         }
     }
 
-#line 7922 "reflect.h2"
+#line 8094 "reflect.h2"
     [[nodiscard]] auto group_token::reverse() const -> token_ptr{
         auto r {CPP2_UFCS_TEMPLATE(cpp2_new<group_token>)(cpp2::shared)}; 
         (*cpp2::impl::assert_not_null(r)).number = number;
@@ -11984,7 +12160,7 @@ size_t i{0};
         return r; 
     }
 
-#line 7930 "reflect.h2"
+#line 8102 "reflect.h2"
     [[nodiscard]] auto group_token::gen_string(cpp2::impl::in<std::string> name, cpp2::impl::in<bool> name_brackets, cpp2::impl::in<bool> has_modifier, cpp2::impl::in<std::string> modifiers, cpp2::impl::in<token_ptr> inner_) -> std::string
     {
         std::string start {"("}; 
@@ -12003,7 +12179,7 @@ size_t i{0};
         return cpp2::move(start) + (*cpp2::impl::assert_not_null(inner_)).to_string() + ")"; 
     }
 
-#line 7948 "reflect.h2"
+#line 8120 "reflect.h2"
     auto group_token::generate_code(generation_context& ctx) const -> void
     {
         if (-1 != number) {
@@ -12035,7 +12211,7 @@ size_t i{0};
         }
     }
 
-#line 7979 "reflect.h2"
+#line 8151 "reflect.h2"
     auto group_token::add_groups(std::set<int>& groups) const -> void
     {
         (*cpp2::impl::assert_not_null(inner)).add_groups(groups);
@@ -12046,7 +12222,7 @@ size_t i{0};
 
     group_token::~group_token() noexcept{}
 
-#line 7991 "reflect.h2"
+#line 8163 "reflect.h2"
 [[nodiscard]] auto hexadecimal_token_parse(parse_context& ctx) -> token_ptr
 {
     if (!((ctx.current() == '\\' && ctx.peek() == 'x'))) {return nullptr; }
@@ -12085,7 +12261,7 @@ size_t i{0};
     return r; 
 }
 
-#line 8032 "reflect.h2"
+#line 8204 "reflect.h2"
 [[nodiscard]] auto line_end_token_parse(parse_context& ctx) -> token_ptr
 {
     if (ctx.current() == '$' || (ctx.current() == '\\' && ctx.peek() == '$')) {
@@ -12103,7 +12279,7 @@ size_t i{0};
     }}
 }
 
-#line 8052 "reflect.h2"
+#line 8224 "reflect.h2"
 [[nodiscard]] auto line_start_token_parse(parse_context& ctx) -> token_ptr
 {
     if (ctx.current() != '^' && !((ctx.current() == '\\' && ctx.peek() == 'A'))) {return nullptr; }
@@ -12117,16 +12293,16 @@ size_t i{0};
     }
 }
 
-#line 8078 "reflect.h2"
+#line 8250 "reflect.h2"
     lookahead_lookbehind_token::lookahead_lookbehind_token(cpp2::impl::in<bool> lookahead_, cpp2::impl::in<bool> positive_)
         : regex_token{ "" }
         , lookahead{ lookahead_ }
         , positive{ positive_ }{
 
-#line 8081 "reflect.h2"
+#line 8253 "reflect.h2"
     }
 
-#line 8083 "reflect.h2"
+#line 8255 "reflect.h2"
     auto lookahead_lookbehind_token::generate_code(generation_context& ctx) const -> void{
         auto inner_name {ctx.generate_func(inner)}; 
 
@@ -12138,7 +12314,7 @@ size_t i{0};
         }
     }
 
-#line 8094 "reflect.h2"
+#line 8266 "reflect.h2"
     [[nodiscard]] auto lookahead_lookbehind_token::reverse() const -> token_ptr{
         auto r {CPP2_UFCS_TEMPLATE(cpp2_new<lookahead_lookbehind_token>)(cpp2::shared, lookahead, positive)}; 
         (*cpp2::impl::assert_not_null(r)).inner = inner;// We do not reverse here. Nested lookahead and lookbehind stay as they are.
@@ -12146,14 +12322,14 @@ size_t i{0};
         return r; 
     }
 
-#line 8101 "reflect.h2"
+#line 8273 "reflect.h2"
     auto lookahead_lookbehind_token::add_groups(std::set<int>& groups) const -> void{
         (*cpp2::impl::assert_not_null(inner)).add_groups(groups);
     }
 
     lookahead_lookbehind_token::~lookahead_lookbehind_token() noexcept{}
 
-#line 8109 "reflect.h2"
+#line 8281 "reflect.h2"
 [[nodiscard]] auto named_class_token_parse(parse_context& ctx) -> token_ptr
 {
     if (ctx.current() != '\\') {return nullptr; }
@@ -12179,7 +12355,7 @@ size_t i{0};
     return CPP2_UFCS_TEMPLATE(cpp2_new<regex_token_check>)(cpp2::shared, "\\" + cpp2::to_string(ctx.current()) + "", "" + cpp2::to_string(cpp2::move(name)) + "<char, " + cpp2::to_string(ctx.get_modifiers().has(expression_flags::case_insensitive)) + ">::match"); 
 }
 
-#line 8137 "reflect.h2"
+#line 8309 "reflect.h2"
 [[nodiscard]] auto octal_token_parse(parse_context& ctx) -> token_ptr
 {
     if (!((ctx.current() == '\\' && ctx.peek() == 'o'))) {return nullptr; }
@@ -12205,11 +12381,11 @@ size_t i{0};
     return r; 
 }
 
-#line 8174 "reflect.h2"
+#line 8346 "reflect.h2"
     range_token::range_token()
                              : regex_token{ "" }{}
 
-#line 8176 "reflect.h2"
+#line 8348 "reflect.h2"
     [[nodiscard]] auto range_token::parse(parse_context& ctx) -> token_ptr
     {
         auto r {CPP2_UFCS_TEMPLATE(cpp2_new<range_token>)(cpp2::shared)}; 
@@ -12283,7 +12459,7 @@ size_t i{0};
         return nullptr; 
     }
 
-#line 8249 "reflect.h2"
+#line 8421 "reflect.h2"
     auto range_token::parse_modifier(parse_context& ctx) & -> void
     {
         if (ctx.peek() == '?') {
@@ -12296,7 +12472,7 @@ size_t i{0};
         }}
     }
 
-#line 8261 "reflect.h2"
+#line 8433 "reflect.h2"
     [[nodiscard]] auto range_token::gen_mod_string() const& -> std::string
     {
         if (kind == range_flags::not_greedy) {
@@ -12310,7 +12486,7 @@ size_t i{0};
         }}
     }
 
-#line 8274 "reflect.h2"
+#line 8446 "reflect.h2"
     [[nodiscard]] auto range_token::gen_range_string() const& -> std::string
     {
         std::string r {""}; 
@@ -12330,7 +12506,7 @@ size_t i{0};
         return r; 
     }
 
-#line 8293 "reflect.h2"
+#line 8465 "reflect.h2"
     [[nodiscard]] auto range_token::reverse() const -> token_ptr{
         auto r {CPP2_UFCS_TEMPLATE(cpp2_new<range_token>)(cpp2::shared)}; 
         (*cpp2::impl::assert_not_null(r)).min_count = min_count;
@@ -12341,7 +12517,7 @@ size_t i{0};
         return r; 
     }
 
-#line 8303 "reflect.h2"
+#line 8475 "reflect.h2"
     auto range_token::generate_code(generation_context& ctx) const -> void
     {
         auto inner_name {ctx.generate_func(inner_token)}; 
@@ -12353,14 +12529,14 @@ size_t i{0};
         ctx.add_statefull(next_name, "cpp2::regex::range_token_matcher<char, " + cpp2::to_string(min_count) + ", " + cpp2::to_string(max_count) + ", " + cpp2::to_string(kind) + ">::match(" + cpp2::to_string(ctx.match_parameters()) + ", " + cpp2::to_string(cpp2::move(inner_name)) + ", " + cpp2::to_string(cpp2::move(reset_name)) + ", other, " + cpp2::to_string(next_name) + ")");
     }
 
-#line 8314 "reflect.h2"
+#line 8486 "reflect.h2"
     auto range_token::add_groups(std::set<int>& groups) const -> void{
         (*cpp2::impl::assert_not_null(inner_token)).add_groups(groups);
     }
 
     range_token::~range_token() noexcept{}
 
-#line 8326 "reflect.h2"
+#line 8498 "reflect.h2"
     [[nodiscard]] auto special_range_token::parse(parse_context& ctx) -> token_ptr
     {
         auto r {CPP2_UFCS_TEMPLATE(cpp2_new<special_range_token>)(cpp2::shared)}; 
@@ -12384,7 +12560,7 @@ size_t i{0};
 
         if (!(ctx.has_token())) {return ctx.error("'" + cpp2::to_string(ctx.current()) + "' without previous element."); }
 
-#line 8350 "reflect.h2"
+#line 8522 "reflect.h2"
         (*cpp2::impl::assert_not_null(r)).parse_modifier(ctx);
 
         (*cpp2::impl::assert_not_null(r)).inner_token = ctx.pop_token();
@@ -12394,7 +12570,7 @@ size_t i{0};
 
     special_range_token::~special_range_token() noexcept{}
 
-#line 8362 "reflect.h2"
+#line 8534 "reflect.h2"
 [[nodiscard]] auto start_match_parse(parse_context& ctx) -> token_ptr
 {
     if (ctx.current() != '\\') {return nullptr; }
@@ -12410,7 +12586,7 @@ size_t i{0};
     }
 }
 
-#line 8382 "reflect.h2"
+#line 8554 "reflect.h2"
 [[nodiscard]] auto word_boundary_token_parse(parse_context& ctx) -> token_ptr
 {
     if (ctx.current() != '\\') {return nullptr; }
@@ -12428,15 +12604,15 @@ size_t i{0};
     }}
 }
 
-#line 8418 "reflect.h2"
+#line 8590 "reflect.h2"
     template <typename Error_out> regex_generator<Error_out>::regex_generator(cpp2::impl::in<std::string_view> r, Error_out const& e)
         : regex{ r }
         , error_out{ e }{
 
-#line 8421 "reflect.h2"
+#line 8593 "reflect.h2"
     }
 
-#line 8423 "reflect.h2"
+#line 8595 "reflect.h2"
     template <typename Error_out> [[nodiscard]] auto regex_generator<Error_out>::parse() & -> std::string
     {
         // Extract modifiers and adapt regex.
@@ -12472,7 +12648,7 @@ size_t i{0};
         return source; 
     }
 
-#line 8458 "reflect.h2"
+#line 8630 "reflect.h2"
     template <typename Error_out> auto regex_generator<Error_out>::extract_modifiers() & -> void
     {
         if (regex.find_first_of("'/") == 0) {
@@ -12488,7 +12664,7 @@ size_t i{0};
         }
     }
 
-#line 8474 "reflect.h2"
+#line 8646 "reflect.h2"
 template<typename Err> [[nodiscard]] auto generate_regex(cpp2::impl::in<std::string_view> regex, Err const& err) -> std::string
 {
     regex_generator<Err> parser {regex, err}; 
@@ -12497,7 +12673,7 @@ template<typename Err> [[nodiscard]] auto generate_regex(cpp2::impl::in<std::str
     return r; 
 }
 
-#line 8484 "reflect.h2"
+#line 8656 "reflect.h2"
 auto regex_gen(meta::type_declaration& t) -> void
 {
     auto has_default {false}; 
@@ -12552,7 +12728,7 @@ auto regex_gen(meta::type_declaration& t) -> void
     CPP2_UFCS(add_runtime_support_include)(t, "cpp2regex.h");
 }
 
-#line 8543 "reflect.h2"
+#line 8715 "reflect.h2"
 [[nodiscard]] auto apply_metafunctions(
     declaration_node& n, 
     type_declaration& rtype, 
@@ -12619,6 +12795,9 @@ auto regex_gen(meta::type_declaration& t) -> void
         else {if (name == "hashable") {
             hashable(rtype);
         }
+        else {if (name == "euclidean_vector") {
+            euclidean_vector(rtype);
+        }
         else {if (name == "basic_value") {
             basic_value(rtype);
         }
@@ -12674,13 +12853,13 @@ auto regex_gen(meta::type_declaration& t) -> void
                 "https://hsutter.github.io/cppfront/cpp2/metafunctions/#built-in-metafunctions"
             );
             return false; 
-        }}}}}}}}}}}}}}}}}}}}}}}}
+        }}}}}}}}}}}}}}}}}}}}}}}}}
     }
 
     return true; 
 }
 
-#line 8671 "reflect.h2"
+#line 8846 "reflect.h2"
 }
 
 }
diff --git a/source/reflect.h2 b/source/reflect.h2
index d228d8aac..1cc0361be 100644
--- a/source/reflect.h2
+++ b/source/reflect.h2
@@ -1786,6 +1786,178 @@ hashable: (inout t: meta::type_declaration) =
 }
 
 
+//-----------------------------------------------------------------------
+//
+//  euclidean_vector
+//  (a little metafunction experiment)
+//
+//  Automatically generate +, -, * and / operators across all member variables, optionally with
+//  a single numeric type argument (eg. vector3 * float) if given a template argument. 
+//
+//  Additionally creates functions For getting the magnitude/length, normalisation, dot product.
+//
+euclidean_vector: (inout t: meta::type_declaration) =
+{
+    single_arg_type: _ = t.get_argument(0);
+    add_single_arg_fns: bool = ( single_arg_type.size() != 0 );
+
+    op_add: std::string = "operator+: (this, in_ref other: (t.name())$) -> (t.name())$ = (t.name())$( ";
+    op_sub: std::string = "operator-: (this, in_ref other: (t.name())$) -> (t.name())$ = (t.name())$( ";
+    op_mul: std::string = "operator*: (this, in_ref other: (t.name())$) -> (t.name())$ = (t.name())$( ";
+    op_div: std::string = "operator/: (this, in_ref other: (t.name())$) -> (t.name())$ = (t.name())$( ";
+
+    op_negate: std::string = "operator-: (this) -> (t.name())$ = (t.name())$( ";
+
+    op_assign_add: std::string = "operator+=: (inout this, in_ref other: (t.name())$) = { ";
+    op_assign_sub: std::string = "operator-=: (inout this, in_ref other: (t.name())$) = { ";
+    op_assign_mul: std::string = "operator*=: (inout this, in_ref other: (t.name())$) = { ";
+    op_assign_div: std::string = "operator/=: (inout this, in_ref other: (t.name())$) = { ";
+
+    op_add_sc: std::string = "operator+: (this, other: (single_arg_type)$) -> (t.name())$ = (t.name())$( ";
+    op_sub_sc: std::string = "operator-: (this, other: (single_arg_type)$) -> (t.name())$ = (t.name())$( ";
+    op_mul_sc: std::string = "operator*: (this, other: (single_arg_type)$) -> (t.name())$ = (t.name())$( ";
+    op_div_sc: std::string = "operator/: (this, other: (single_arg_type)$) -> (t.name())$ = (t.name())$( ";
+
+    op_assign_add_sc: std::string = "operator+=: (inout this, other: (single_arg_type)$) = { ";
+    op_assign_sub_sc: std::string = "operator-=: (inout this, other: (single_arg_type)$) = { ";
+    op_assign_mul_sc: std::string = "operator*=: (inout this, other: (single_arg_type)$) = { ";
+    op_assign_div_sc: std::string = "operator/=: (inout this, other: (single_arg_type)$) = { ";
+
+    fn_lengthSq: std::string = "lengthSquared: (this) -> _ = ";
+
+    fn_normalise: std::string = "normalise: (inout this) = {\n    len: _ = length();\n";
+    fn_normalised: std::string = "normalised: (this) -> (t.name())$ = {\n    len: _ = length();\n    return (t.name())$(\n";
+
+    fn_dot: std::string = "dot: (in_ref lhs: (t.name())$, in_ref rhs: (t.name())$) -> _ = ";
+
+    after_first_value_added: bool = false;
+    for  t.get_member_objects()
+    do   (o)
+    {
+        if after_first_value_added {
+            op_add += ", ";
+            op_sub += ", ";
+            op_mul += ", ";
+            op_div += ", ";
+
+            op_negate += ", ";
+
+            if add_single_arg_fns {
+                op_add_sc += ", ";
+                op_sub_sc += ", ";
+                op_mul_sc += ", ";
+                op_div_sc += ", ";
+            }
+
+            fn_lengthSq += " + ";
+            fn_dot += " + ";
+
+            fn_normalised += ",\n";
+        } else {
+            fn_normalised += "\n";
+        }
+
+        op_add += "(o.name())$ + other.(o.name())$";
+        op_sub += "(o.name())$ - other.(o.name())$";
+        op_mul += "(o.name())$ * other.(o.name())$";
+        op_div += "(o.name())$ / other.(o.name())$";
+
+        op_negate += "-(o.name())$";
+
+        fn_normalise += "(o.name())$ /= len;\n";
+        fn_normalised += "    (o.name())$ / len";
+
+        if add_single_arg_fns {
+            op_add_sc += "(o.name())$ + other";
+            op_sub_sc += "(o.name())$ - other";
+            op_mul_sc += "(o.name())$ * other";
+            op_div_sc += "(o.name())$ / other";
+        }
+
+        op_assign_add += "(o.name())$ += other.(o.name())$;";
+        op_assign_sub += "(o.name())$ -= other.(o.name())$;";
+        op_assign_mul += "(o.name())$ *= other.(o.name())$;";
+        op_assign_div += "(o.name())$ /= other.(o.name())$;";
+
+        if add_single_arg_fns {
+            op_assign_add_sc += "(o.name())$ += other;";
+            op_assign_sub_sc += "(o.name())$ -= other;";
+            op_assign_mul_sc += "(o.name())$ *= other;";
+            op_assign_div_sc += "(o.name())$ /= other;";
+        }
+
+        fn_lengthSq += "( (o.name())$ * (o.name())$ )";
+        fn_dot += "( lhs.(o.name())$ * rhs.(o.name())$ )";
+
+        after_first_value_added = true;
+    }
+
+    op_assign_add += " }";
+    op_assign_sub += " }";
+    op_assign_mul += " }";
+    op_assign_div += " }";
+
+    if add_single_arg_fns {
+        op_assign_add_sc += " }";
+        op_assign_sub_sc += " }";
+        op_assign_mul_sc += " }";
+        op_assign_div_sc += " }";
+    }
+
+    op_add += " );";
+    op_sub += " );";
+    op_mul += " );";
+    op_div += " );";
+
+    op_negate += " );";
+
+    if add_single_arg_fns {
+        op_add_sc += " );";
+        op_sub_sc += " );";
+        op_mul_sc += " );";
+        op_div_sc += " );";
+    }
+
+    fn_lengthSq += ";";
+    fn_dot += ";";
+
+    fn_normalise += "}";
+    fn_normalised += ");\n}";
+
+    t.add_member( fn_lengthSq );
+    t.add_member( "length: (this) -> _ = std::sqrt( lengthSquared() );" );
+
+    t.add_member( fn_normalise );
+    t.add_member( fn_normalised );
+
+    t.add_member( fn_dot );
+
+    t.add_member( op_add );
+    t.add_member( op_sub );
+    t.add_member( op_mul );
+    t.add_member( op_div );
+
+    t.add_member( op_negate );
+
+    t.add_member( op_assign_add );
+    t.add_member( op_assign_sub );
+    t.add_member( op_assign_mul );
+    t.add_member( op_assign_div );
+
+    if add_single_arg_fns {
+        t.add_member( op_add_sc );
+        t.add_member( op_sub_sc );
+        t.add_member( op_mul_sc );
+        t.add_member( op_div_sc );
+
+        t.add_member( op_assign_add_sc );
+        t.add_member( op_assign_sub_sc );
+        t.add_member( op_assign_mul_sc );
+        t.add_member( op_assign_div_sc );
+    }
+}
+
+
 //-----------------------------------------------------------------------
 //
 //  basic_value
@@ -8606,6 +8778,9 @@ apply_metafunctions: (
         else if name == "hashable" {
             hashable( rtype );
         }
+        else if name == "euclidean_vector" {
+            euclidean_vector( rtype );
+        }
         else if name == "basic_value" {
             basic_value( rtype );
         }