diff --git a/regression-tests/pure2-default-arguments.cpp2 b/regression-tests/pure2-default-arguments.cpp2
index c558582293..df0adfdda9 100644
--- a/regression-tests/pure2-default-arguments.cpp2
+++ b/regression-tests/pure2-default-arguments.cpp2
@@ -11,19 +11,52 @@ my_function_name: (
 
 f: (x: i32 = 0) = { std::cout << x; }
 
+combine_maps:
+    < 
+        AssocContainer, 
+        Func: type = std::plus<> 
+    >
+    ( 
+        inout map1: AssocContainer, 
+              map2: AssocContainer, 
+              func: Func = () 
+    )
+= {
+    for map2 do(kv) {
+        map1[kv.first] = func(map1[kv.first], kv.second);
+    }
+}
+
+myclass: <T: type = int, N: int = 42> type = { 
+    memfunc: <TT: type = int, NN: int = 42> (MM: int = 43) = { _ = MM; }
+}
+myfunc:  <T: type = int, N: int = 42> (M: int = 43) = {
+    _ = M;
+    : <TT: type = int, NN: int = 42> (MM: int = 43) = { _ = MM; };
+}
+
 main: (args) = {
     my_function_name();
     f();
     f(1);
     f(2);
 
-    : <V: bool = gcc_clang_msvc_min_versions( 1400, 1600, 1920)> () = {
+    : <V: bool = gcc_clang_msvc_min_versions( 1400, 1600, 1920 )> () = {
         if constexpr V {
-            std::cout << "a newer compiler\n";
+            std::cout << "\na newer compiler\n";
         }
         else {
-            std::cout << "an older compiler\n";
+            std::cout << "\nan older compiler\n";
         }
     } ();
 
+    m1: std::map<int, int> = ();
+    m1[1] = 11;
+
+    m2: std::map<int, int> = ();
+    m2[1] = 22;
+
+    combine_maps( m1, m2, :(x,y) x+y+33 );
+
+    std::cout << "(m1.size())$, (m2.size())$, (m1[1])$\n";
 }
diff --git a/regression-tests/test-results/clang-12-c++20/mixed-bugfix-for-ufcs-non-local.cpp.output b/regression-tests/test-results/clang-12-c++20/mixed-bugfix-for-ufcs-non-local.cpp.output
index f9e8cae868..a94faf4f22 100644
--- a/regression-tests/test-results/clang-12-c++20/mixed-bugfix-for-ufcs-non-local.cpp.output
+++ b/regression-tests/test-results/clang-12-c++20/mixed-bugfix-for-ufcs-non-local.cpp.output
@@ -107,7 +107,7 @@ mixed-bugfix-for-ufcs-non-local.cpp2:27:29: error: a lambda expression cannot ap
 #define CPP2_UFCS_(LAMBDADEFCAPT,SFINAE,MVFWD,QUALID,TEMPKW,...) \
                                                                  ^
 mixed-bugfix-for-ufcs-non-local.cpp2:41:84: error: lambda expression in an unevaluated operand
-  inline CPP2_CONSTEXPR bool u::c{ [](cpp2::impl::in<std::type_identity_t<decltype(CPP2_UFCS_NONLOCAL(f)(o))>> x) mutable -> auto { return x; }(true) };// Fails on Clang 12 (lambda in unevaluated context).
+  inline CPP2_CONSTEXPR bool u::c{ [](cpp2::impl::in<std::type_identity_t<decltype(CPP2_UFCS_NONLOCAL(f)(o))>> x) -> auto { return x; }(true) };// Fails on Clang 12 (lambda in unevaluated context).
                                                                                    ^
 ../../../include/cpp2util.h:2137:59: note: expanded from macro 'CPP2_UFCS_NONLOCAL'
 #define CPP2_UFCS_NONLOCAL(...)                           CPP2_UFCS_(,CPP2_UFCS_IDENTITY,CPP2_UFCS_IDENTITY,(),,__VA_ARGS__)
diff --git a/regression-tests/test-results/clang-12-c++20/pure2-bugfix-for-non-local-function-expression.cpp.output b/regression-tests/test-results/clang-12-c++20/pure2-bugfix-for-non-local-function-expression.cpp.output
index b82b091296..7922990a5a 100644
--- a/regression-tests/test-results/clang-12-c++20/pure2-bugfix-for-non-local-function-expression.cpp.output
+++ b/regression-tests/test-results/clang-12-c++20/pure2-bugfix-for-non-local-function-expression.cpp.output
@@ -1,10 +1,10 @@
 pure2-bugfix-for-non-local-function-expression.cpp2:5:34: error: lambda expression in an unevaluated operand
-template<typename T> concept v = []() mutable -> bool { return true;  }(); 
+template<typename T> concept v = []() -> bool { return true;  }(); 
                                  ^
 pure2-bugfix-for-non-local-function-expression.cpp2:7:41: error: lambda expression in an unevaluated operand
-using u = std::type_identity_t<decltype([]() mutable -> void{})>;
+using u = std::type_identity_t<decltype([]() -> void{})>;
                                         ^
 pure2-bugfix-for-non-local-function-expression.cpp2:9:47: error: lambda expression in an unevaluated operand
-class t: public std::type_identity_t<decltype([]() mutable -> void{})> {
+class t: public std::type_identity_t<decltype([]() -> void{})> {
                                               ^
 3 errors generated.
diff --git a/regression-tests/test-results/clang-12-c++20/pure2-last-use.cpp.output b/regression-tests/test-results/clang-12-c++20/pure2-last-use.cpp.output
index 5ba32d082e..9696e76e39 100644
--- a/regression-tests/test-results/clang-12-c++20/pure2-last-use.cpp.output
+++ b/regression-tests/test-results/clang-12-c++20/pure2-last-use.cpp.output
@@ -1,4 +1,4 @@
 pure2-last-use.cpp2:945:44: error: a lambda expression cannot appear in this context
-    static_cast<void>([_0 = std::array<int,[](auto const& x) mutable -> auto { return identity(x); }(0)>()]() mutable -> auto { return _0;  });// Fails on Clang 12 (lambda in unevaluated context).
+    static_cast<void>([_0 = std::array<int,[](auto const& x) -> auto { return identity(x); }(0)>()]() mutable -> auto { return _0;  });// Fails on Clang 12 (lambda in unevaluated context).
                                            ^
 1 error generated.
diff --git a/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution b/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution
index 13c1bc1e73..0d1459552f 100644
--- a/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution
+++ b/regression-tests/test-results/gcc-14-c++2b/pure2-default-arguments.cpp.execution
@@ -1,2 +1,4 @@
 calling: int main(int, char**)
-012an older compiler
+012
+a newer compiler
+1, 1, 66
diff --git a/regression-tests/test-results/mixed-bugfix-for-ufcs-non-local.cpp b/regression-tests/test-results/mixed-bugfix-for-ufcs-non-local.cpp
index d38515e197..1992bf7230 100644
--- a/regression-tests/test-results/mixed-bugfix-for-ufcs-non-local.cpp
+++ b/regression-tests/test-results/mixed-bugfix-for-ufcs-non-local.cpp
@@ -95,7 +95,7 @@ auto g() -> void{
 
 #line 40 "mixed-bugfix-for-ufcs-non-local.cpp2"
   inline CPP2_CONSTEXPR bool u::b{ CPP2_UFCS_NONLOCAL(f)(o) };
-  inline CPP2_CONSTEXPR bool u::c{ [](cpp2::impl::in<std::type_identity_t<decltype(CPP2_UFCS_NONLOCAL(f)(o))>> x) mutable -> auto { return x; }(true) };// Fails on Clang 12 (lambda in unevaluated context).
+  inline CPP2_CONSTEXPR bool u::c{ [](cpp2::impl::in<std::type_identity_t<decltype(CPP2_UFCS_NONLOCAL(f)(o))>> x) -> auto { return x; }(true) };// Fails on Clang 12 (lambda in unevaluated context).
   auto u::g(auto const& s, auto const& sz) -> void{
                                   if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(sz)(s) != 0) ) { cpp2::cpp2_default.report_violation(""); }}
 
diff --git a/regression-tests/test-results/mixed-function-expression-and-std-for-each.cpp b/regression-tests/test-results/mixed-function-expression-and-std-for-each.cpp
index 00334f9d93..a7f84b5077 100644
--- a/regression-tests/test-results/mixed-function-expression-and-std-for-each.cpp
+++ b/regression-tests/test-results/mixed-function-expression-and-std-for-each.cpp
@@ -32,11 +32,11 @@
     //  Passing a function expression
     std::ranges::for_each(
         vec, 
-        [](auto& x) mutable -> void { x += "-ish";  }
+        [](auto& x) -> void { x += "-ish";  }
     );
 
     //  Initializing from a function expression
-    auto callback {[](auto& x) mutable -> void { x += " maybe";  }}; 
+    auto callback {[](auto& x) -> void { x += " maybe";  }}; 
     std::ranges::for_each(
         vec, 
         cpp2::move(callback)
diff --git a/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each-with-capture.cpp b/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each-with-capture.cpp
index 0a0ecab7ff..0757df9820 100644
--- a/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each-with-capture.cpp
+++ b/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each-with-capture.cpp
@@ -34,7 +34,7 @@
     std::ranges::for_each
         (vec, [_0 = cpp2::move(y)](auto const& x) mutable -> void { std::cout << x << _0;  });
 
-    auto callback {[](auto& x) mutable -> void { x += "-ish";  }}; 
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
     std::ranges::for_each(vec, cpp2::move(callback));
 
     for ( auto const& str : cpp2::move(vec) ) 
diff --git a/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each.cpp b/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each.cpp
index d7b4d897dd..2455575355 100644
--- a/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each.cpp
+++ b/regression-tests/test-results/mixed-function-expression-and-std-ranges-for-each.cpp
@@ -31,9 +31,9 @@
             "hello", "2022"}; 
 
     std::ranges::for_each
-        (vec, [](auto const& x) mutable -> void { std::cout << x << "\n";  });
+        (vec, [](auto const& x) -> void { std::cout << x << "\n";  });
 
-    auto callback {[](auto& x) mutable -> void { x += "-ish";  }}; 
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
     std::ranges::for_each(vec, cpp2::move(callback));
 
     for ( auto const& str : cpp2::move(vec) ) 
diff --git a/regression-tests/test-results/mixed-function-expression-with-pointer-capture.cpp b/regression-tests/test-results/mixed-function-expression-with-pointer-capture.cpp
index 2c43711e0c..030701eed5 100644
--- a/regression-tests/test-results/mixed-function-expression-with-pointer-capture.cpp
+++ b/regression-tests/test-results/mixed-function-expression-with-pointer-capture.cpp
@@ -35,7 +35,7 @@
         std::cout << CPP2_UFCS(c_str)((*cpp2::impl::assert_not_null(_0))) << x << *cpp2::impl::assert_not_null(_0);  }
     );
 
-    auto callback {[](auto& x) mutable -> void { x += "-ish";  }}; 
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
     std::ranges::for_each(vec, cpp2::move(callback));
 
     for ( auto const& str : cpp2::move(vec) ) 
diff --git a/regression-tests/test-results/mixed-function-expression-with-repeated-capture.cpp b/regression-tests/test-results/mixed-function-expression-with-repeated-capture.cpp
index 05de2409bb..a584f50231 100644
--- a/regression-tests/test-results/mixed-function-expression-with-repeated-capture.cpp
+++ b/regression-tests/test-results/mixed-function-expression-with-repeated-capture.cpp
@@ -34,7 +34,7 @@
     std::ranges::for_each
         (vec, [_0 = cpp2::move(y)](auto const& x) mutable -> void { std::cout << _0 << x << _0;  });
 
-    auto callback {[](auto& x) mutable -> void { x += "-ish";  }}; 
+    auto callback {[](auto& x) -> void { x += "-ish";  }}; 
     std::ranges::for_each(vec, cpp2::move(callback));
 
     for ( auto const& str : cpp2::move(vec) ) 
diff --git a/regression-tests/test-results/msvc-2022-c++latest/pure2-default-arguments.cpp.execution b/regression-tests/test-results/msvc-2022-c++latest/pure2-default-arguments.cpp.execution
index 75f26d0fc7..28b9d2515f 100644
--- a/regression-tests/test-results/msvc-2022-c++latest/pure2-default-arguments.cpp.execution
+++ b/regression-tests/test-results/msvc-2022-c++latest/pure2-default-arguments.cpp.execution
@@ -1,2 +1,4 @@
 calling: int __cdecl main(const int,char **)
-012a newer compiler
+012
+a newer compiler
+1, 1, 66
diff --git a/regression-tests/test-results/pure2-bugfix-for-non-local-function-expression.cpp b/regression-tests/test-results/pure2-bugfix-for-non-local-function-expression.cpp
index 43165f8fec..90b4f54a1f 100644
--- a/regression-tests/test-results/pure2-bugfix-for-non-local-function-expression.cpp
+++ b/regression-tests/test-results/pure2-bugfix-for-non-local-function-expression.cpp
@@ -20,11 +20,11 @@ class t;
 //  Standalone Cpp1 repro: https://godbolt.org/z/dznnYTvc6
 
 #line 5 "pure2-bugfix-for-non-local-function-expression.cpp2"
-template<typename T> concept v = []() mutable -> bool { return true;  }(); 
+template<typename T> concept v = []() -> bool { return true;  }(); 
 
-using u = std::type_identity_t<decltype([]() mutable -> void{})>;
+using u = std::type_identity_t<decltype([]() -> void{})>;
 
-class t: public std::type_identity_t<decltype([]() mutable -> void{})> {
+class t: public std::type_identity_t<decltype([]() -> void{})> {
 
 };
 
diff --git a/regression-tests/test-results/pure2-bugfix-for-ufcs-arguments.cpp b/regression-tests/test-results/pure2-bugfix-for-ufcs-arguments.cpp
index 1b5d5c582c..874b79fa80 100644
--- a/regression-tests/test-results/pure2-bugfix-for-ufcs-arguments.cpp
+++ b/regression-tests/test-results/pure2-bugfix-for-ufcs-arguments.cpp
@@ -151,7 +151,7 @@ auto main() -> int{
   static_cast<void>(CPP2_UFCS_TEMPLATE(f<t,t>)(n, 0, 0));
   static_cast<void>(CPP2_UFCS_TEMPLATE(f<t,t>)(a<t,t>, 0, 0));
 
-  static_cast<void>([](auto const& a, auto const& f) mutable -> void{static_cast<void>(CPP2_UFCS(f)(CPP2_UFCS(f)(a, a))); });
+  static_cast<void>([](auto const& a, auto const& f) -> void{static_cast<void>(CPP2_UFCS(f)(CPP2_UFCS(f)(a, a))); });
   // _ = 0.std::min<int>(0);
   static_cast<void>(CPP2_UFCS_QUALIFIED_TEMPLATE((ns::t<0,0>::),f<0>)(0));
 }
diff --git a/regression-tests/test-results/pure2-bugfix-for-ufcs-name-lookup.cpp b/regression-tests/test-results/pure2-bugfix-for-ufcs-name-lookup.cpp
index cf63c6e8ad..63c62c6adc 100644
--- a/regression-tests/test-results/pure2-bugfix-for-ufcs-name-lookup.cpp
+++ b/regression-tests/test-results/pure2-bugfix-for-ufcs-name-lookup.cpp
@@ -98,7 +98,7 @@ auto const& f{t().f()};
     static_assert(f == 0);
   }
   {
-    auto f {[](auto const& f) mutable -> auto{
+    auto f {[](auto const& f) -> auto{
       if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(f)(t()) == 0) ) { cpp2::cpp2_default.report_violation(""); }
       return CPP2_UFCS(f)(u()); 
     }(identity())}; 
@@ -112,7 +112,7 @@ auto const& f{t().f()};
     // _ = f;
   }
   {
-    auto f {[]() mutable -> void{
+    auto f {[]() -> void{
 {
 cpp2::impl::in<identity> f{identity()};
 #line 59 "pure2-bugfix-for-ufcs-name-lookup.cpp2"
@@ -128,7 +128,7 @@ cpp2::impl::in<identity> f{identity()};
     static_cast<void>(cpp2::move(f));
   }
   {
-    auto f {[]() mutable -> void{
+    auto f {[]() -> void{
       using ns::f;
       static_assert(CPP2_UFCS(f)(t()) == 0);
       // static_assert(u().f() == 1);
@@ -136,18 +136,18 @@ cpp2::impl::in<identity> f{identity()};
     static_cast<void>(cpp2::move(f));
   }
   {
-    auto f {[]() mutable -> void{
+    auto f {[]() -> void{
       static_assert(t().f() == 0);
-      auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) mutable -> std::void_t<decltype(T().f())>{}}; 
+      auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) -> std::void_t<decltype(T().f())>{}}; 
       static_assert(!(std::is_invocable_v<decltype(cpp2::move(g)),u>));
       using ns::f;
     }}; 
     static_cast<void>(cpp2::move(f));
   }
   {
-    auto f {[]() mutable -> void{
+    auto f {[]() -> void{
       using ns::f;
-      static_cast<void>([]() mutable -> void{
+      static_cast<void>([]() -> void{
         static_assert(CPP2_UFCS(f)(t()) == 0);
         // static_assert(u().f() == 1);
       });
@@ -159,15 +159,15 @@ cpp2::impl::in<identity> f{identity()};
     static_cast<void>(cpp2::move(f));
   }
   {
-    auto f {[]() mutable -> void{
-      static_cast<void>([]() mutable -> void{
+    auto f {[]() -> void{
+      static_cast<void>([]() -> void{
         static_assert(t().f() == 0);
-        auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) mutable -> std::void_t<decltype(T().f())>{}}; 
+        auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) -> std::void_t<decltype(T().f())>{}}; 
         static_assert(!(std::is_invocable_v<decltype(cpp2::move(g)),u>));
       });
       {
         static_assert(t().f() == 0);
-        auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) mutable -> std::void_t<decltype(T().f())>{}}; 
+        auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) -> std::void_t<decltype(T().f())>{}}; 
         static_assert(!(std::is_invocable_v<decltype(cpp2::move(g)),u>));
       }
       using ns::f;
diff --git a/regression-tests/test-results/pure2-bugfix-for-ufcs-sfinae.cpp b/regression-tests/test-results/pure2-bugfix-for-ufcs-sfinae.cpp
index 9e60913ad2..a6ea35ca86 100644
--- a/regression-tests/test-results/pure2-bugfix-for-ufcs-sfinae.cpp
+++ b/regression-tests/test-results/pure2-bugfix-for-ufcs-sfinae.cpp
@@ -34,7 +34,7 @@ template<typename T> [[nodiscard]] auto f() -> std::type_identity_t<decltype(CPP
 
 #line 5 "pure2-bugfix-for-ufcs-sfinae.cpp2"
 auto main() -> int{
-  auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) mutable -> std::void_t<decltype(f<T>())>{}}; 
+  auto g {[]<typename T>([[maybe_unused]] T const& unnamed_param_1) -> std::void_t<decltype(f<T>())>{}}; 
   static_assert(!(std::is_invocable_v<decltype(cpp2::move(g)),B>));
 }
 
diff --git a/regression-tests/test-results/pure2-bugfix-for-unbraced-function-expression.cpp b/regression-tests/test-results/pure2-bugfix-for-unbraced-function-expression.cpp
index b9d9091ed6..0b39483a32 100644
--- a/regression-tests/test-results/pure2-bugfix-for-unbraced-function-expression.cpp
+++ b/regression-tests/test-results/pure2-bugfix-for-unbraced-function-expression.cpp
@@ -42,16 +42,16 @@ extern cpp2::i32 y;
 {
 auto const& x{t()};
 #line 6 "pure2-bugfix-for-unbraced-function-expression.cpp2"
-  {CPP2_ASSERT_IN_BOUNDS(x, []() mutable -> auto { return 0;  }); }
+  {CPP2_ASSERT_IN_BOUNDS(x, []() -> auto { return 0;  }); }
 }
 {
 auto const& x{t()};
 #line 7 "pure2-bugfix-for-unbraced-function-expression.cpp2"
-  {CPP2_ASSERT_IN_BOUNDS(x, []() mutable -> auto { return 0;  }); }
+  {CPP2_ASSERT_IN_BOUNDS(x, []() -> auto { return 0;  }); }
 }
 
 #line 9 "pure2-bugfix-for-unbraced-function-expression.cpp2"
-  if (cpp2::cpp2_default.is_active() && !(!((cpp2::impl::is<int>([]() mutable -> auto { return 0; })))) ) { cpp2::cpp2_default.report_violation(""); }
+  if (cpp2::cpp2_default.is_active() && !(!((cpp2::impl::is<int>([]() -> auto { return 0; })))) ) { cpp2::cpp2_default.report_violation(""); }
 
   return cpp2::i32{0}; 
 }
diff --git a/regression-tests/test-results/pure2-default-arguments.cpp b/regression-tests/test-results/pure2-default-arguments.cpp
index ed1553a0cc..dc692b3b9e 100644
--- a/regression-tests/test-results/pure2-default-arguments.cpp
+++ b/regression-tests/test-results/pure2-default-arguments.cpp
@@ -8,6 +8,9 @@
 
 #line 1 "pure2-default-arguments.cpp2"
 
+#line 30 "pure2-default-arguments.cpp2"
+template<typename T = int, int N = 42> class myclass;
+    
 
 //=== Cpp2 type definitions and function declarations ===========================
 
@@ -24,6 +27,29 @@ auto my_function_name(
 #line 12 "pure2-default-arguments.cpp2"
 auto f(cpp2::impl::in<cpp2::i32> x = 0) -> void;
 
+template
+    <
+        typename AssocContainer, 
+        typename Func = std::plus<>
+    > auto combine_maps
+    (
+        AssocContainer& map1, 
+              AssocContainer const& map2, 
+              Func const& func = {}
+    ) -> void;
+
+#line 30 "pure2-default-arguments.cpp2"
+template<typename T, int N> class myclass {
+    public: template<typename TT = int, int NN = 42> static auto memfunc(cpp2::impl::in<int> MM = 43) -> void;
+    public: myclass() = default;
+    public: myclass(myclass const&) = delete; /* No 'that' constructor, suppress copy */
+    public: auto operator=(myclass const&) -> void = delete;
+
+#line 32 "pure2-default-arguments.cpp2"
+};
+template <typename T = int, int N  = 42> auto myfunc(cpp2::impl::in<int> M = 43) -> void;
+
+#line 38 "pure2-default-arguments.cpp2"
 auto main(int const argc_, char** argv_) -> int;
 
 //=== Cpp2 function definitions =================================================
@@ -42,22 +68,57 @@ auto my_function_name(
 auto f(cpp2::impl::in<cpp2::i32> x) -> void{std::cout << x; }
 
 #line 14 "pure2-default-arguments.cpp2"
+template
+    <
+        typename AssocContainer, 
+        typename Func
+    > auto combine_maps
+    (
+        AssocContainer& map1, 
+              AssocContainer const& map2, 
+              Func const& func
+    ) -> void
+{
+    for ( auto const& kv : map2 ) {
+        CPP2_ASSERT_IN_BOUNDS(map1, kv.first) = func(CPP2_ASSERT_IN_BOUNDS(map1, kv.first), kv.second);
+    }
+}
+
+#line 31 "pure2-default-arguments.cpp2"
+    template <typename T, int N> template<typename TT, int NN> auto myclass<T,N>::memfunc(cpp2::impl::in<int> MM) -> void{static_cast<void>(MM); }
+
+#line 33 "pure2-default-arguments.cpp2"
+template <typename T,       int N> auto myfunc(cpp2::impl::in<int> M) -> void{
+    static_cast<void>(M);
+    []<typename TT = int, int NN = 42>(cpp2::impl::in<int> MM = 43) -> void{static_cast<void>(MM); };
+}
+
+#line 38 "pure2-default-arguments.cpp2"
 auto main(int const argc_, char** argv_) -> int{
     auto const args = cpp2::make_args(argc_, argv_); 
-#line 15 "pure2-default-arguments.cpp2"
+#line 39 "pure2-default-arguments.cpp2"
     my_function_name();
     f();
     f(1);
     f(2);
 
-    []<bool V = gcc_clang_msvc_min_versions(1400, 1600, 1920)>() mutable -> void{
+    []<bool V = gcc_clang_msvc_min_versions(1400, 1600, 1920)>() -> void{
         if constexpr (V) {
-            std::cout << "a newer compiler\n";
+            std::cout << "\na newer compiler\n";
         }
         else {
-            std::cout << "an older compiler\n";
+            std::cout << "\nan older compiler\n";
         }
     }();
 
+    std::map<int,int> m1 {}; 
+    CPP2_ASSERT_IN_BOUNDS_LITERAL(m1, 1) = 11;
+
+    std::map<int,int> m2 {}; 
+    CPP2_ASSERT_IN_BOUNDS_LITERAL(m2, 1) = 22;
+
+    combine_maps(m1, m2, [](auto const& x, auto const& y) -> auto { return x + y + 33;  });
+
+    std::cout << "" + cpp2::to_string(CPP2_UFCS(size)(m1)) + ", " + cpp2::to_string(CPP2_UFCS(size)(cpp2::move(m2))) + ", " + cpp2::to_string(CPP2_ASSERT_IN_BOUNDS_LITERAL(m1, 1)) + "\n";
 }
 
diff --git a/regression-tests/test-results/pure2-for-loop-range-with-lambda.cpp b/regression-tests/test-results/pure2-for-loop-range-with-lambda.cpp
index 110a0e2612..1005f102c3 100644
--- a/regression-tests/test-results/pure2-for-loop-range-with-lambda.cpp
+++ b/regression-tests/test-results/pure2-for-loop-range-with-lambda.cpp
@@ -38,19 +38,19 @@ auto main(int const argc_, char** argv_) -> int{
    }
 
    // Used to cause Error
-   for (                      auto const& i : CPP2_UFCS(first)(ints, [](auto const& x) mutable -> auto { return x; }) ) {
+   for (                      auto const& i : CPP2_UFCS(first)(ints, [](auto const& x) -> auto { return x; }) ) {
       std::cout << i;
    }
 
    // OK
-   auto temp {CPP2_UFCS(first)(cpp2::move(ints), [](auto const& x) mutable -> auto { return x;  })}; 
+   auto temp {CPP2_UFCS(first)(cpp2::move(ints), [](auto const& x) -> auto { return x;  })}; 
    for ( auto const& i : cpp2::move(temp) ) {
       std::cout << i;
    }
 
    for ( auto const& i : [_0 = args]() mutable -> auto { return _0;  }() ) static_cast<void>(i); 
-   for ( auto const& j : [](auto const& x) mutable -> auto { return x;  }(args) ) static_cast<void>(j); 
-   for ( auto const& k : [](auto const& x) mutable -> auto { return x;  }(args) )  { do static_cast<void>(k);  while (false); static_cast<void>([_0 = args]() mutable -> auto { return _0;  }()); }
-   for ( auto const& l : [](auto const& x) mutable -> auto { return x;  }(args) )  { do static_cast<void>(l);  while (false); static_cast<void>([](auto const& x) mutable -> auto { return x;  }(args)); }
+   for ( auto const& j : [](auto const& x) -> auto { return x;  }(args) ) static_cast<void>(j); 
+   for ( auto const& k : [](auto const& x) -> auto { return x;  }(args) )  { do static_cast<void>(k);  while (false); static_cast<void>([_0 = args]() mutable -> auto { return _0;  }()); }
+   for ( auto const& l : [](auto const& x) -> auto { return x;  }(args) )  { do static_cast<void>(l);  while (false); static_cast<void>([](auto const& x) -> auto { return x;  }(args)); }
 }
 
diff --git a/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp b/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp
index 20b3d04ec1..6b9d04a6bc 100644
--- a/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp
+++ b/regression-tests/test-results/pure2-is-with-unnamed-predicates.cpp
@@ -22,15 +22,15 @@ auto fun(auto const& v) -> void;
 #line 1 "pure2-is-with-unnamed-predicates.cpp2"
 auto fun(auto const& v) -> void{
 #line 2 "pure2-is-with-unnamed-predicates.cpp2"
-    if (cpp2::impl::is(v, ([](cpp2::impl::in<int> x) mutable -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
+    if (cpp2::impl::is(v, ([](cpp2::impl::in<int> x) -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
         std::cout << "" + cpp2::to_string(v) + " is integer bigger than 3" << std::endl;
     }
 
-    if (cpp2::impl::is(v, ([](cpp2::impl::in<double> x) mutable -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
+    if (cpp2::impl::is(v, ([](cpp2::impl::in<double> x) -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
         std::cout << "" + cpp2::to_string(v) + " is double bigger than 3" << std::endl;
     }
 
-    if (cpp2::impl::is(v, ([](auto const& x) mutable -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
+    if (cpp2::impl::is(v, ([](auto const& x) -> auto { return cpp2::impl::cmp_greater(x,3); }))) {
         std::cout << "" + cpp2::to_string(v) + " is bigger than 3" << std::endl;
     }
 }
diff --git a/regression-tests/test-results/pure2-last-use.cpp b/regression-tests/test-results/pure2-last-use.cpp
index 00b935bd7b..75b20ca258 100644
--- a/regression-tests/test-results/pure2-last-use.cpp
+++ b/regression-tests/test-results/pure2-last-use.cpp
@@ -576,7 +576,7 @@ auto issue_313() -> void{
 //     a := new<int>(0);
 //     return (a&**, identity_copy(a)*);
 //   };
-  static_cast<void>([]() mutable -> int{
+  static_cast<void>([]() -> int{
     auto a {cpp2_new<int>(0)}; 
     return *cpp2::impl::assert_not_null(identity(a)) + *cpp2::impl::assert_not_null(identity(a)); 
 
@@ -639,7 +639,7 @@ auto issue_313_1(std::unique_ptr<int> x) -> void{
 auto issue_350() -> void{
     auto x {21}; 
 
-    auto l1 {[](auto&& x) mutable -> void{
+    auto l1 {[](auto&& x) -> void{
         f_inout(CPP2_FORWARD(x));
     }}; 
 
@@ -660,9 +660,9 @@ auto issue_683(auto const& args) -> void{
 
 #line 114 "pure2-last-use.cpp2"
 auto issue_825() -> void{
-  static_cast<void>([](std::unique_ptr<int> b) mutable -> auto { return f_copy(std::move(cpp2::move(b)));  });
-  static_cast<void>([](std::unique_ptr<int>&& c) mutable -> auto { return f_copy(std::move(cpp2::move(c)));  });
-  static_cast<void>([](auto&& d) mutable -> auto { return f_copy(CPP2_FORWARD(d));  }(cpp2_new<int>(0)));
+  static_cast<void>([](std::unique_ptr<int> b) -> auto { return f_copy(std::move(cpp2::move(b)));  });
+  static_cast<void>([](std::unique_ptr<int>&& c) -> auto { return f_copy(std::move(cpp2::move(c)));  });
+  static_cast<void>([](auto&& d) -> auto { return f_copy(CPP2_FORWARD(d));  }(cpp2_new<int>(0)));
 }
 
 #line 120 "pure2-last-use.cpp2"
@@ -868,7 +868,7 @@ issue_869_1::issue_869_1(issue_869_1 const& that)
 return res; }
 #line 380 "pure2-last-use.cpp2"
 auto issue_884() -> void{
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {}
     {
@@ -877,7 +877,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       f_copy(std::move(cpp2::move(x)));
@@ -888,7 +888,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       f_inout(x);
@@ -900,7 +900,7 @@ auto issue_884() -> void{
     f_copy(std::move(cpp2::move(x)));
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_copy(std::move(cpp2::move(x)));
     if (true) {
@@ -913,7 +913,7 @@ auto issue_884() -> void{
     static_cast<void>(0);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -926,7 +926,7 @@ auto issue_884() -> void{
     static_cast<void>(0);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -939,7 +939,7 @@ auto issue_884() -> void{
     static_cast<void>(0);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -952,7 +952,7 @@ auto issue_884() -> void{
     static_cast<void>(0);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -965,7 +965,7 @@ auto issue_884() -> void{
     f_copy(std::move(cpp2::move(x)));
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -978,7 +978,7 @@ auto issue_884() -> void{
     static_cast<void>(0);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -991,7 +991,7 @@ auto issue_884() -> void{
     static_cast<void>(0);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -1007,7 +1007,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -1023,7 +1023,7 @@ auto issue_884() -> void{
     f_copy(std::move(cpp2::move(x)));
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     if (true) {
@@ -1039,7 +1039,7 @@ auto issue_884() -> void{
     static_cast<void>(0);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       if (true) {
@@ -1052,7 +1052,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       if (true) {
@@ -1066,7 +1066,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
     }
@@ -1079,7 +1079,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       f_copy(std::move(cpp2::move(x)));
@@ -1093,7 +1093,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       auto y {cpp2_new<int>(0)}; 
@@ -1110,7 +1110,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       auto y {cpp2_new<int>(0)}; 
@@ -1132,7 +1132,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       auto y {cpp2_new<int>(0)}; 
@@ -1156,7 +1156,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       f_copy(std::move(cpp2::move(x)));
@@ -1175,7 +1175,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       if (true) {
@@ -1194,7 +1194,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
 
     if (true) {
@@ -1208,7 +1208,7 @@ auto issue_884() -> void{
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       if (true) {
@@ -1385,14 +1385,14 @@ return std::move(p.value()); }
 
 #line 876 "pure2-last-use.cpp2"
 auto loops() -> void{
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     for ( 
     [[maybe_unused]] auto const& unnamed_param_1 : { 0 } ) 
     f_inout(x);
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     for ( 
 
@@ -1400,14 +1400,14 @@ auto loops() -> void{
     {} while (false); f_inout(x); }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     for ( 
     [[maybe_unused]] auto const& unnamed_param_1 : { 0 } ) 
     if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(get)(x)) ) { cpp2::cpp2_default.report_violation(""); }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     if (true) {
       f_copy(std::move(cpp2::move(x)));
@@ -1426,7 +1426,7 @@ namespace captures {
 auto f() -> void{
   auto x {cpp2_new<int>(0)}; 
   f_copy(std::move(cpp2::move(x)));
-  auto id {[](auto const& x) mutable -> auto&& { return x;  }}; 
+  auto id {[](auto const& x) -> auto&& { return x;  }}; 
   auto y {cpp2_new<int>(0)}; 
   if (cpp2::cpp2_default.is_active() && !(&cpp2::move(id)(y) == &y) ) { cpp2::cpp2_default.report_violation(""); }
 }
@@ -1434,7 +1434,7 @@ auto f() -> void{
 #line 928 "pure2-last-use.cpp2"
   auto t::operator()() && -> void{
     f_copy(std::move(cpp2::move(*this).x));
-    static_cast<void>([&]() mutable -> void{
+    static_cast<void>([&]() -> void{
       // Should this move?
       // I.e., don't skip non-captured names, just rely on skipping hiding names.
       // An odr-use still requires capturing at Cpp1-time, and capturing would move.
@@ -1452,13 +1452,13 @@ auto t::operator=(auto const& x_) -> t& {
                                              return *this;}
 #line 941 "pure2-last-use.cpp2"
 auto g() -> void{
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_copy(std::move(cpp2::move(x)));
-    static_cast<void>([_0 = std::array<int,[](auto const& x) mutable -> auto { return identity(x); }(0)>()]() mutable -> auto { return _0;  });// Fails on Clang 12 (lambda in unevaluated context).
+    static_cast<void>([_0 = std::array<int,[](auto const& x) -> auto { return identity(x); }(0)>()]() mutable -> auto { return _0;  });// Fails on Clang 12 (lambda in unevaluated context).
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     static_cast<void>([_0 = ([_0 = cpp2::move(x)]() mutable -> auto { return *cpp2::impl::assert_not_null(_0); })]() mutable -> int { return _0();  });
@@ -1469,21 +1469,21 @@ auto g() -> void{
 
 #line 957 "pure2-last-use.cpp2"
 auto loops_and_captures() -> void{
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_copy(std::move(cpp2::move(x)));
     for ( 
-    [[maybe_unused]] auto const& unnamed_param_1 : { [](auto const& x) mutable -> auto { return x; } } ) 
+    [[maybe_unused]] auto const& unnamed_param_1 : { [](auto const& x) -> auto { return x; } } ) 
     {}
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_copy(std::move(cpp2::move(x)));
     for ( 
 
 #line 973 "pure2-last-use.cpp2"
-    [[maybe_unused]] auto const& unnamed_param_1 : { []() mutable -> auto{using captures::x;return x; } } ) 
+    [[maybe_unused]] auto const& unnamed_param_1 : { []() -> auto{using captures::x;return x; } } ) 
     {}
   });
 
@@ -1503,7 +1503,7 @@ auto types::operator=(auto const& x_) -> types& {
                                              return *this;}
 #line 995 "pure2-last-use.cpp2"
 auto skip_hidden_names() -> void{
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_copy(std::move(cpp2::move(x)));
 {
@@ -1526,7 +1526,7 @@ auto x{cpp2_new<int>(0)};
 //     };
 //   };
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
 {
 auto x{cpp2_new<int>(0)};
     // x := new<int>(0);
@@ -1541,7 +1541,7 @@ auto x{cpp2_new<int>(0)};
 #line 1022 "pure2-last-use.cpp2"
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_inout(x);
     {
@@ -1551,10 +1551,10 @@ auto x{cpp2_new<int>(0)};
     }
   });
 
-  static_cast<void>([]() mutable -> void{
+  static_cast<void>([]() -> void{
     auto x {cpp2_new<int>(0)}; 
     f_copy(std::move(cpp2::move(x)));
-    static_cast<void>([]() mutable -> void{
+    static_cast<void>([]() -> void{
       static_assert(std::is_same_v<decltype(x),std::unique_ptr<int>>);
       using captures::x;
       f_inout(x);
diff --git a/regression-tests/test-results/pure2-look-up-parameter-across-unnamed-function.cpp b/regression-tests/test-results/pure2-look-up-parameter-across-unnamed-function.cpp
index b3ac1a346e..5bc1c674d4 100644
--- a/regression-tests/test-results/pure2-look-up-parameter-across-unnamed-function.cpp
+++ b/regression-tests/test-results/pure2-look-up-parameter-across-unnamed-function.cpp
@@ -33,7 +33,7 @@ using g_ret = int;
 [[nodiscard]] auto f() -> f_ret{
     int ri {0};
 #line 3 "pure2-look-up-parameter-across-unnamed-function.cpp2"
-    auto pred {[](auto const& e) mutable -> auto { return e == 1;  }}; 
+    auto pred {[](auto const& e) -> auto { return e == 1;  }}; 
     ri = 42;
     cpp2::move(pred)(ri);
     return ri; // "return;" is implicit"
@@ -44,7 +44,7 @@ using g_ret = int;
         cpp2::impl::deferred_init<int> ri;
 #line 10 "pure2-look-up-parameter-across-unnamed-function.cpp2"
     ri.construct(0);
-    auto pred {[](auto const& e) mutable -> auto { return e == 1;  }}; 
+    auto pred {[](auto const& e) -> auto { return e == 1;  }}; 
     ri.value() = 42;
     cpp2::move(pred)(ri.value());
     return std::move(ri.value()); 
diff --git a/regression-tests/test-results/pure2-print.cpp b/regression-tests/test-results/pure2-print.cpp
index a131b49911..74103903ed 100644
--- a/regression-tests/test-results/pure2-print.cpp
+++ b/regression-tests/test-results/pure2-print.cpp
@@ -123,9 +123,9 @@ requires (true) inline CPP2_CONSTEXPR T outer::object_alias{ 42 };
             if (cpp2::cpp2_default.is_active() && !(CPP2_UFCS(empty)(m) == false || false) ) { cpp2::cpp2_default.report_violation(CPP2_CONTRACT_MSG("message")); }
             if (testing_enabled && cpp2::bounds_safety.is_active() && !([_0 = 0, _1 = CPP2_UFCS(ssize)(m), _2 = 100]{ return cpp2::impl::cmp_less(_0,_1) && cpp2::impl::cmp_less(_1,_2); }() && true != false) ) { cpp2::bounds_safety.report_violation(CPP2_CONTRACT_MSG("size is " + cpp2::to_string(CPP2_UFCS(ssize)(m)) + "")); }
 #line 37 "pure2-print.cpp2"
-            auto a {[]() mutable -> void{}}; 
-            auto b {[]() mutable -> void{}}; 
-            auto c {[]() mutable -> void{}}; 
+            auto a {[]() -> void{}}; 
+            auto b {[]() -> void{}}; 
+            auto c {[]() -> void{}}; 
 
             for( ; CPP2_UFCS(empty)(s); a() ) {break; }
 
diff --git a/regression-tests/test-results/pure2-range-operators.cpp b/regression-tests/test-results/pure2-range-operators.cpp
index 482697236b..8a3ece53b5 100644
--- a/regression-tests/test-results/pure2-range-operators.cpp
+++ b/regression-tests/test-results/pure2-range-operators.cpp
@@ -60,7 +60,7 @@ auto main() -> int{
     std::cout << "" + cpp2::to_string(CPP2_UFCS(contains)((cpp2::range(1,20)), 21)) + "\n";// prints false
 
     //  Only run these parts on implementations that support views::take
-    []<bool V = gcc_clang_msvc_min_versions(1400, 1600, 1920)>() mutable -> void{
+    []<bool V = gcc_clang_msvc_min_versions(1400, 1600, 1920)>() -> void{
         if constexpr (V) 
         {
             using namespace std::views;
diff --git a/regression-tests/test-results/pure2-regex_01_char_matcher.cpp b/regression-tests/test-results/pure2-regex_01_char_matcher.cpp
index 05c6300d18..6b86193a90 100644
--- a/regression-tests/test-results/pure2-regex_01_char_matcher.cpp
+++ b/regression-tests/test-results/pure2-regex_01_char_matcher.cpp
@@ -372,14 +372,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_02_ranges.cpp b/regression-tests/test-results/pure2-regex_02_ranges.cpp
index f0dccd16d1..d55f6ea1e3 100644
--- a/regression-tests/test-results/pure2-regex_02_ranges.cpp
+++ b/regression-tests/test-results/pure2-regex_02_ranges.cpp
@@ -1500,14 +1500,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_03_wildcard.cpp b/regression-tests/test-results/pure2-regex_03_wildcard.cpp
index 10ffe1c3bd..c514f45110 100644
--- a/regression-tests/test-results/pure2-regex_03_wildcard.cpp
+++ b/regression-tests/test-results/pure2-regex_03_wildcard.cpp
@@ -750,14 +750,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_04_start_end.cpp b/regression-tests/test-results/pure2-regex_04_start_end.cpp
index e703460eaf..1434f05180 100644
--- a/regression-tests/test-results/pure2-regex_04_start_end.cpp
+++ b/regression-tests/test-results/pure2-regex_04_start_end.cpp
@@ -294,14 +294,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_05_classes.cpp b/regression-tests/test-results/pure2-regex_05_classes.cpp
index 9918773cfe..b4da63c1fc 100644
--- a/regression-tests/test-results/pure2-regex_05_classes.cpp
+++ b/regression-tests/test-results/pure2-regex_05_classes.cpp
@@ -554,14 +554,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_06_boundaries.cpp b/regression-tests/test-results/pure2-regex_06_boundaries.cpp
index 5d863f1455..14ed22489a 100644
--- a/regression-tests/test-results/pure2-regex_06_boundaries.cpp
+++ b/regression-tests/test-results/pure2-regex_06_boundaries.cpp
@@ -502,14 +502,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_07_short_classes.cpp b/regression-tests/test-results/pure2-regex_07_short_classes.cpp
index 7a37ed3f99..313e2170b0 100644
--- a/regression-tests/test-results/pure2-regex_07_short_classes.cpp
+++ b/regression-tests/test-results/pure2-regex_07_short_classes.cpp
@@ -684,14 +684,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_08_alternatives.cpp b/regression-tests/test-results/pure2-regex_08_alternatives.cpp
index 73d79613c5..f2b188adcc 100644
--- a/regression-tests/test-results/pure2-regex_08_alternatives.cpp
+++ b/regression-tests/test-results/pure2-regex_08_alternatives.cpp
@@ -142,14 +142,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_09_groups.cpp b/regression-tests/test-results/pure2-regex_09_groups.cpp
index 6019e25a88..173497cef9 100644
--- a/regression-tests/test-results/pure2-regex_09_groups.cpp
+++ b/regression-tests/test-results/pure2-regex_09_groups.cpp
@@ -346,14 +346,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_10_escapes.cpp b/regression-tests/test-results/pure2-regex_10_escapes.cpp
index ab395e4e91..1429f5f94b 100644
--- a/regression-tests/test-results/pure2-regex_10_escapes.cpp
+++ b/regression-tests/test-results/pure2-regex_10_escapes.cpp
@@ -660,14 +660,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_11_group_references.cpp b/regression-tests/test-results/pure2-regex_11_group_references.cpp
index f4c118e458..3c3d92bfec 100644
--- a/regression-tests/test-results/pure2-regex_11_group_references.cpp
+++ b/regression-tests/test-results/pure2-regex_11_group_references.cpp
@@ -804,14 +804,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp b/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp
index 780f43d3e9..e7f458bd83 100644
--- a/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp
+++ b/regression-tests/test-results/pure2-regex_12_case_insensitive.cpp
@@ -4599,14 +4599,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp b/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp
index af21c800bc..6eadb84dbf 100644
--- a/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp
+++ b/regression-tests/test-results/pure2-regex_13_possessive_modifier.cpp
@@ -2308,14 +2308,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp b/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp
index 77ab52574d..7d1a420fb6 100644
--- a/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp
+++ b/regression-tests/test-results/pure2-regex_14_multiline_modifier.cpp
@@ -5234,14 +5234,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp b/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp
index d0627954f6..e37a2af4e1 100644
--- a/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp
+++ b/regression-tests/test-results/pure2-regex_15_group_modifiers.cpp
@@ -1468,14 +1468,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp b/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp
index a50cf334bd..fae5594a96 100644
--- a/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp
+++ b/regression-tests/test-results/pure2-regex_16_perl_syntax_modifier.cpp
@@ -1078,14 +1078,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_17_comments.cpp b/regression-tests/test-results/pure2-regex_17_comments.cpp
index be7466eecb..911640ec73 100644
--- a/regression-tests/test-results/pure2-regex_17_comments.cpp
+++ b/regression-tests/test-results/pure2-regex_17_comments.cpp
@@ -158,14 +158,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_18_branch_reset.cpp b/regression-tests/test-results/pure2-regex_18_branch_reset.cpp
index 8d652d8331..9687565e93 100644
--- a/regression-tests/test-results/pure2-regex_18_branch_reset.cpp
+++ b/regression-tests/test-results/pure2-regex_18_branch_reset.cpp
@@ -980,14 +980,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-regex_19_lookahead.cpp b/regression-tests/test-results/pure2-regex_19_lookahead.cpp
index 3783e7a50b..2a2dc42935 100644
--- a/regression-tests/test-results/pure2-regex_19_lookahead.cpp
+++ b/regression-tests/test-results/pure2-regex_19_lookahead.cpp
@@ -2240,14 +2240,14 @@ auto main() -> int;
    return CPP2_UFCS(cend)((*cpp2::impl::assert_not_null(_0))); 
   }
   }}; 
-  auto extract_group_and_advance {[](auto& iter) mutable -> auto{
+  auto extract_group_and_advance {[](auto& iter) -> auto{
     auto start {iter}; 
 
     for( ; std::isdigit(*cpp2::impl::assert_not_null(iter)); ++iter ) {}
 
     return std::stoi(std::string(cpp2::move(start), iter)); 
   }}; 
-  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) mutable -> auto{
+  auto extract_until {[](auto& iter, cpp2::impl::in<char> to) -> auto{
     auto start {iter}; 
 
     for( ; (to != *cpp2::impl::assert_not_null(iter)); ++iter ) {}// TODO: Without bracket: error: postfix unary * (dereference) cannot be immediately followed by a (, identifier, or literal - add whitespace before * here if you meant binary * (multiplication)
diff --git a/regression-tests/test-results/pure2-types-order-independence-and-nesting.cpp b/regression-tests/test-results/pure2-types-order-independence-and-nesting.cpp
index 3947a102c0..752a107ced 100644
--- a/regression-tests/test-results/pure2-types-order-independence-and-nesting.cpp
+++ b/regression-tests/test-results/pure2-types-order-independence-and-nesting.cpp
@@ -150,7 +150,7 @@ namespace N {
 #line 35 "pure2-types-order-independence-and-nesting.cpp2"
     auto X::exx(cpp2::impl::in<int> count) const& -> void{
         //  Exercise '_' anonymous objects too while we're at it
-        cpp2::finally auto_1 {[&]() mutable -> void { std::cout << "leaving call to 'why(" + cpp2::to_string(count) + ")'\n";  }}; 
+        cpp2::finally auto_1 {[&]() -> void { std::cout << "leaving call to 'why(" + cpp2::to_string(count) + ")'\n";  }}; 
         if (cpp2::impl::cmp_less(count,5)) {
             CPP2_UFCS(why)((*cpp2::impl::assert_not_null(py)), count + 1);// use Y object from X
         }
diff --git a/source/parse.h b/source/parse.h
index 3671458823..7f0a4c1105 100644
--- a/source/parse.h
+++ b/source/parse.h
@@ -601,6 +601,9 @@ struct expression_node
         return {};
     }
 
+    auto is_empty_expression_list() const
+        -> bool;
+
     auto is_literal() const
         -> bool
     {
@@ -715,6 +718,12 @@ struct expression_list_node
 
     //  API
     //
+    auto is_empty() const
+        -> bool
+    {
+        return expressions.empty();
+    }
+
     auto is_fold_expression() const
         -> bool
     {
@@ -822,6 +831,13 @@ struct expression_statement_node
 
     //  API
     //
+    auto is_empty_expression_list() const
+        -> bool
+    {
+        assert(expr);
+        return expr->is_empty_expression_list();
+    }
+
     auto subexpression_count() const
         -> int
     {
@@ -866,6 +882,17 @@ auto expression_node::is_standalone_expression() const
 }
 
 
+auto expression_node::is_empty_expression_list() const
+    -> bool
+{
+    auto expr_list = get_expression_list();
+    return
+        expr_list
+        && expr_list->is_empty()
+        ;
+}
+
+
 struct capture {
     postfix_expression_node* capture_expr;
     std::string              cap_sym = {};
diff --git a/source/reflect.h b/source/reflect.h
index 7593428450..bce6e9f60d 100644
--- a/source/reflect.h
+++ b/source/reflect.h
@@ -2866,7 +2866,7 @@ auto cpp2_enum(meta::type_declaration& t) -> void
 {
     //  Let basic_enum do its thing, with an incrementing value generator
     CPP2_UFCS(basic_enum)(t, 
-        [](std::string& value, cpp2::impl::in<std::string> specified_value) mutable -> void{
+        [](std::string& value, cpp2::impl::in<std::string> specified_value) -> void{
             if (!(CPP2_UFCS(empty)(specified_value))) {
                 value = specified_value;
             }else {
@@ -2894,7 +2894,7 @@ auto flag_enum(meta::type_declaration& t) -> void
 {
     //  Let basic_enum do its thing, with a power-of-two value generator
     CPP2_UFCS(basic_enum)(t, 
-        [](std::string& value, cpp2::impl::in<std::string> specified_value) mutable -> void{
+        [](std::string& value, cpp2::impl::in<std::string> specified_value) -> void{
             if (!(CPP2_UFCS(empty)(specified_value))) {
                 value = specified_value;
             }else {
diff --git a/source/sema.h b/source/sema.h
index 08f1690e72..dd703b1ad9 100644
--- a/source/sema.h
+++ b/source/sema.h
@@ -2316,8 +2316,12 @@ class sema
 
     auto start(parameter_declaration_node const& n, int) -> void
     {
-        //  Ignore parameters in function type-ids
-        if (n.is_in_function_typeid()) {
+        //  Ignore parameters in function type-ids and local templates
+        if (
+            n.is_in_function_typeid()
+            || n.is_in_template_param_list()
+            )
+        {
             return;
         }
 
diff --git a/source/to_cpp1.h b/source/to_cpp1.h
index 71c24239c5..537caec27b 100644
--- a/source/to_cpp1.h
+++ b/source/to_cpp1.h
@@ -4401,27 +4401,36 @@ class cppfront
         //
         auto emit_initializer = [&]
         {
+            assert(n.declaration);
             auto is_param_to_namespace_scope_type =
                 n.declaration->parent_is_type() 
                 && n.declaration->parent_declaration->parent_is_namespace() 
                 ;
 
+            auto emit_in_phase_0 =
+                is_param_to_namespace_scope_type
+                && printer.get_phase() == printer.phase0_type_decls
+                ;
+
+            auto emit_in_phase_1 =
+                !is_param_to_namespace_scope_type
+                && printer.get_phase() == printer.phase1_type_defs_func_decls
+                ;
+
             if (
                 !is_returns
                 && n.declaration->initializer
                 && (
-                    n.is_in_function_scope()    // implies we're in phase 2
-                    || (
-                        is_param_to_namespace_scope_type
-                        && printer.get_phase() == printer.phase0_type_decls
-                        )
-                    || (
-                        !is_param_to_namespace_scope_type
-                        && printer.get_phase() == printer.phase1_type_defs_func_decls
-                        )
+                    n.is_in_function_scope()    // implies we're in phase 1 or 2
+                    || emit_in_phase_0
+                    || emit_in_phase_1
                     )
                 )
             {
+                auto expr  = n.declaration->initializer->get_if<expression_statement_node>();
+                assert(expr->expr);
+                auto empty = expr && expr->is_empty_expression_list();
+
                 auto guard = stack_element(current_declarations, &*n.declaration);
                 if (is_statement) {
                     printer.print_cpp2( "{", n.declaration->initializer->position() );
@@ -4429,7 +4438,14 @@ class cppfront
                 else {
                     printer.print_cpp2( " = ", n.declaration->initializer->position() );
                 }
-                emit(*n.declaration->initializer, false);
+
+                if (empty && !is_statement) {
+                    printer.print_cpp2( "{}", n.declaration->initializer->position() );
+                }
+                else {
+                    emit(*n.declaration->initializer, false);
+                }
+
                 if (is_statement) {
                     printer.print_cpp2( "};", n.declaration->initializer->position() );
                 }
@@ -4514,6 +4530,7 @@ class cppfront
             printer.print_cpp2("typename ", identifier_pos);
 
             emit_template_name();
+            emit_initializer();
             return;
         }
 
@@ -5008,7 +5025,7 @@ class cppfront
                 //  printer.print_cpp2( " constexpr", n.position() );
                 //      // consider enabling when P2242, P2280, and similar papers are widely implemented
             }
-            else {
+            else if (!n.my_decl->captures.members.empty()) {
                 printer.print_cpp2( " mutable", n.position() );
             }
         }