Require '=' for all funcs, default single-expr bodies to -> forward _

Requiring `=` has been a widely-requested change, and I think it does make the code clearer to read. See the Cpp2 code changes in this commit for examples.

For example, `f: () expr;` must now be written as `f: () = expr;`

For a function whose body is a single expression, the default return type (i.e., if not specified) is now `-> forward _`, which is Cpp1 `-> decltype(auto)` (which, importantly, can deduce a value).

With this change, single-expression function bodies without `{ }` are still legal for any function, but as of this commit we have a clearer distinction in their use (which is reflected in the updates to the regression tests and other Cpp2 code in this commit):

    - It further encourages single-expression function bodies without `{ }` for unnamed function expressions (lambdas), by making more of those cases Do the Right Thing that the programmer intended.

    - It naturally discourages their overuse for named functions, because it will more often cause a compiler warning or error:

       - a warning that callers are not using a returned results, when the function is called without using its value

       - an error that a deduced return type makes the function order-dependent, when the function is called from earlier in the source file... this is because a deduced return types creates a dependency on the body, and it is inherent (not an artifact of either Cpp1 or Cpp2)

       But for those who liked that style, fear not, usually the answer is to just put the two characters `{ }` around the body... see examples in this commit, which I have to admit most are probably more readable even though I'm one of the ones who liked omitting the braces.

       Note: I realize that further evolution may not allow the `{ }`-free style for named functions. That may well be a reasonable further outcome.

I think both of these are positive improvements.

Author: hsutter

include/cpp2regex.h

@@ -74,7 +74,7 @@ match_context: <CharT, Iter, max_groups: int> type =
 
     //  Getter and setter for groups
     //
-    get_group: (in this, group) groups[group];
+    get_group: (in this, group) = groups[group];
 
     get_group_end:    (in this, group) -> int = {
         if group >= max_groups || !groups[group].matched {
@@ -108,20 +108,20 @@ match_context: <CharT, Iter, max_groups: int> type =
         groups[group].start = pos;
     }
 
-    size: (in this) max_groups;
+    size: (in this) = max_groups;
 
     //  Misc functions
     //
-    fail: (in this)            match_return<Iter>(false, end);
-    pass: (in this, cur: Iter) match_return<Iter>(true, cur);
+    fail: (in this)            = match_return<Iter>(false, end);
+    pass: (in this, cur: Iter) = match_return<Iter>(true, cur);
 }
 
 
 //  End function that returns a valid match.
 //
 true_end_func: @struct<noforward> type = 
 {
-    operator(): (in this, cur, inout ctx) ctx..pass(cur);
+    operator(): (in this, cur, inout ctx) = ctx..pass(cur);
 }
 
 
@@ -149,7 +149,7 @@ on_return: <Func> type =
 
 
 //  Helper for auto deduction of the Func type.
-make_on_return: <Func> (func: Func) on_return<Func>(func);
+make_on_return: <Func> (func: Func) = on_return<Func>(func);
 
 
 //-----------------------------------------------------------------------
@@ -163,60 +163,60 @@ make_on_return: <Func> (func: Func) on_return<Func>(func);
 //
 single_class_entry: <CharT, C: CharT> type =
 {
-    includes : (c: CharT) c == C;
-    to_string: ()         bstring<CharT>(1, C);
+    includes : (c: CharT) = c == C;
+    to_string: ()         = bstring<CharT>(1, C);
 }
 
 
 //  Class syntax: - Example: a-c
 //
 range_class_entry: <CharT, Start: CharT, End: CharT> type =
 {
-    includes : (c: CharT) Start <= c <= End;
-    to_string: ()         "(Start)$-(End)$";
+    includes : (c: CharT) = Start <= c <= End;
+    to_string: ()         = "(Start)$-(End)$";
 }
 
 
 //  Helper for combining two character classes
 //
 combined_class_entry: <CharT, List ...> type = 
 {
-    includes : (c: CharT) (false || ... || List::includes(c));
-    to_string: ()         (bstring<CharT>() + ... + List::to_string());
+    includes : (c: CharT) = (false || ... || List::includes(c));
+    to_string: ()         = (bstring<CharT>() + ... + List::to_string());
 }
 
 
 //  Class syntax: <list of characters>  Example: abcd
 //
 list_class_entry: <CharT, List ... : CharT> type = 
 {
-    includes : (c: CharT) (false || ... || (List == c));
-    to_string: ()         (bstring<CharT>() + ... + List);
+    includes : (c: CharT) = (false || ... || (List == c));
+    to_string: ()         = (bstring<CharT>() + ... + List);
 }
 
 
 //  Class syntax: [:<class name:]  Example: [:alnum:]
 //
 named_class_entry: <CharT, Name: string_util::fixed_string, Inner> type = 
 {
-    includes : (c: CharT) Inner::includes(c);
-    to_string: ()         "[:(Name..data())$:]";
+    includes : (c: CharT) = Inner::includes(c);
+    to_string: ()         = "[:(Name..data())$:]";
 }
 
 
 negated_class_entry: <CharT, Inner> type = 
 {
     this    : Inner      = ();
-    includes: (c: CharT) !Inner::includes(c);
+    includes: (c: CharT) = !Inner::includes(c);
 }
 
 
 //  Short class syntax: \<character>  Example: \w
 //
 shorthand_class_entry: <CharT, Name: string_util::fixed_string, Inner> type = 
 {
-    includes : (c: CharT) Inner::includes(c);
-    to_string: ()         Name..str();
+    includes : (c: CharT) = Inner::includes(c);
+    to_string: ()         = Name..str();
 }
 
 
@@ -692,14 +692,14 @@ regular_expression: <CharT, matcher_wrapper> type =
             pos = unsafe_narrow<int>(std::distance(ctx_.begin, pos_));
         }
 
-        group_number: (this) ctx..size();
-        group:        (this, g: int) ctx..get_group_string(g);
-        group_start:  (this, g: int) ctx..get_group_start(g);
-        group_end:    (this, g: int) ctx..get_group_end(g);
+        group_number: (this)         = ctx..size();
+        group:        (this, g: int) = ctx..get_group_string(g);
+        group_start:  (this, g: int) = ctx..get_group_start(g);
+        group_end:    (this, g: int) = ctx..get_group_end(g);
 
-        group:        (this, g: bstring<CharT>) group(get_group_id(g));
-        group_start:  (this, g: bstring<CharT>) group_start(get_group_id(g));
-        group_end:    (this, g: bstring<CharT>) group_end(get_group_id(g));
+        group:        (this, g: bstring<CharT>) = group(get_group_id(g));
+        group_start:  (this, g: bstring<CharT>) = group_start(get_group_id(g));
+        group_end:    (this, g: bstring<CharT>) = group_end(get_group_id(g));
 
         private get_group_id: (this, g: bstring<CharT>) -> _ = {
             group_id := matcher<Iter>::get_named_group_index(g);
@@ -710,9 +710,9 @@ regular_expression: <CharT, matcher_wrapper> type =
         }
     }
 
-    match: (in this, str: bview<CharT>)                 match(str..begin(), str..end());
-    match: (in this, str: bview<CharT>, start)          match(get_iter(str, start), str..end());
-    match: (in this, str: bview<CharT>, start, length)  match(get_iter(str, start), get_iter(str, start + length));
+    match: (in this, str: bview<CharT>)                = match(str..begin(), str..end());
+    match: (in this, str: bview<CharT>, start)         = match(get_iter(str, start), str..end());
+    match: (in this, str: bview<CharT>, start, length) = match(get_iter(str, start), get_iter(str, start + length));
     match: <Iter> (in this, start: Iter, end: Iter) -> search_return<Iter> = 
     {
         ctx: context<Iter> = (start, end);
@@ -721,9 +721,9 @@ regular_expression: <CharT, matcher_wrapper> type =
         return search_return<Iter>(r.matched && r.pos == end, ctx, r.pos);
     }
 
-    search: (in this, str: bview<CharT>)                 search(str..begin(), str..end());
-    search: (in this, str: bview<CharT>, start)          search(get_iter(str, start), str..end());
-    search: (in this, str: bview<CharT>, start, length)  search(get_iter(str, start), get_iter(str, start + length));
+    search: (in this, str: bview<CharT>)                = search(str..begin(), str..end());
+    search: (in this, str: bview<CharT>, start)         = search(get_iter(str, start), str..end());
+    search: (in this, str: bview<CharT>, start, length) = search(get_iter(str, start), get_iter(str, start + length));
     search: <Iter> (in this, start: Iter, end: Iter) -> search_return<Iter> = 
     {
         ctx: context<Iter> = (start, end);
@@ -744,7 +744,7 @@ regular_expression: <CharT, matcher_wrapper> type =
         return search_return<Iter>(r.matched, ctx, r.pos);
     }
 
-    to_string: (in this) matcher_wrapper::to_string();
+    to_string: (in this) = matcher_wrapper::to_string();
 
     //  Helper functions
     //

include/cpp2regex.h2

@@ -38,7 +38,7 @@ d: _ == t<o.f()>(); // Fails on Clang 12 (lambda in unevaluated context).
 
 u: @struct type = {
   b: bool == o.f();
-  c: bool == :(x: decltype(o.f())) x;(true); // Fails on Clang 12 (lambda in unevaluated context).
+  c: bool == :(forward x: decltype(f(o))) = x;(true); // Fails on Clang 12 (lambda in unevaluated context).
   g: (s, sz) pre(s.sz() != 0) = { }
 }
 

regression-tests/mixed-bugfix-for-ufcs-non-local.cpp2

@@ -25,7 +25,9 @@ fill: (
     x = value.substr(0, count);
 }
 
-print_decorated: (x:_) = std::cout << ">> [" << x << "]\n";
+print_decorated: (x:_) = { 
+    std::cout << ">> [" << x << "]\n"; 
+}
 
 // for test determinism, force "fill" branch
 bool flip_a_coin() {

regression-tests/mixed-initialization-safety-3-contract-violation.cpp2

@@ -23,7 +23,9 @@ fill: (
     x = value.substr(0, count);
 }
 
-print_decorated: (x:_) = std::cout << ">> [" << x << "]\n";
+print_decorated: (x:_) = { 
+    std::cout << ">> [" << x << "]\n"; 
+}
 
 // for test determinism, force "xyzzy" branch
 // the standard mandates that std::mt19937()() == 3499211612

regression-tests/mixed-initialization-safety-3.cpp2

@@ -1,10 +1,10 @@
 test: (forward v) = {
     std::cout << "v is empty = (v is  void)$" << std::endl;
     std::cout << "v is std::monostate = (v is std::monostate)$" << std::endl;
-    std::cout << "v is X< 0> = (v is X< 0>)$,\t(v as X< 1>) = " << expect_no_throw(forward v, :(forward v) v as X<0>) << std::endl;
+    std::cout << "v is X< 0> = (v is X< 0>)$,\t(v as X< 1>) = " << expect_no_throw(forward v, :(forward v) = v as X<0>) << std::endl;
     std::cout << "v is X< 1> = (v is X< 1>)$,\t(v as X< 1>).to_string() = (expect_no_throw(forward v, :(forward v) -> std::string = { return (v as X< 1>).to_string();}))$" << std::endl;
     std::cout << "v is X<19> = (v is X<19>)$,\t(v as X<19>).to_string() = (expect_no_throw(forward v, :(forward v) -> std::string = { return (v as X<19>).to_string();}))$" << std::endl;
-    std::cout << "v is X<20> = (v is X<20>)$,\t(v as X<20>) = " << expect_no_throw(forward v, :(forward v) v as X<20>) << std::endl;
+    std::cout << "v is X<20> = (v is X<20>)$,\t(v as X<20>) = " << expect_no_throw(forward v, :(forward v) = v as X<20>) << std::endl;
     std::cout << std::endl;
 }
 

regression-tests/mixed-is-as-variant.cpp2

@@ -18,8 +18,9 @@ main: () -> int = {
     print_and_decorate( p* );
 }
 
-print_and_decorate: (thing:_) =
-    std::cout << ">> " << thing << "\n";
+print_and_decorate: (thing:_) = { 
+    std::cout << ">> " << thing << "\n"; 
+}
 
 bool flip_a_coin() {
     // Change std::mt19937 to std::random_device for non-deterministic PRNG

regression-tests/mixed-lifetime-safety-pointer-init-4.cpp2

@@ -19,8 +19,9 @@ f: () -> (i: int, s: std::string) = {
     return;
 }
 
-do_print: (name: std::string, value:_)
-    = std::cout << name << " is " << value << "\n";
+do_print: (name: std::string, value:_) = { 
+    std::cout << name << " is " << value << "\n"; 
+}
 
 int main() {
     auto [a,b] = f();

regression-tests/mixed-multiple-return-values.cpp2

@@ -9,8 +9,9 @@ class Circle : public Shape { };
 class Square : public Shape { };
 
 
-print: <T : type> ( msg: std::string, x: T ) =
+print: <T : type> ( msg: std::string, x: T ) = {
     std::cout << "(msg)$ (x)$\n";
+}
 
 main: () -> int = 
 {

regression-tests/mixed-type-safety-1.cpp2

@@ -12,6 +12,7 @@ main: () -> int
     }
 }
 
-print_and_decorate: (thing:_) =
+print_and_decorate: (thing:_) = {
     std::cout << ">> " << thing << "\n";
+}