Unify expression-bodied and normal method syntax

[OJacot-Descombes]

It feels wrong to have two distinct syntaxes for the same things.

Proposal: If we changed the syntax of methods from method_header ( block | "=>" expression ";") to method_header statement (where statement of course includes block as a possibility) and if we declared return and => to be synonyms, then we could write the same method as

T M() => expr;

// or

T M() return expr;

// or

T M() { return expr; }

// or

T M() { => expr; }

and, as a side-effect, we could write a lambda as

x => x * x

// or

x return x * x

As an exception we should forbid the return keyword in void methods, property setters and constructors; however, we would allow the following syntax in these cases

void Test() Console.WriteLine("test");

 public string Name
 {
     get return locationName;
     set locationName = value;
}

The term "expression-bodied member" would become obsolete in C#.

[HaloFour]

IMO the suggested syntax seems quite confusing and in trying to remove the difference between block-bodied members and expression-bodied members only seems to create 3 or 4 other forms of syntax to accomplish the same thing.

[canton7]

Agreed, this just looks like 2 more ways of writing the same thing, which makes the problem 2x worse. Like https://xkcd.com/927/, but with two new proposed standards.

[OJacot-Descombes]

Right, there are new ways of writing things, but they all comply with the single syntax production rule: method_header statement.

[canton7]

As a user I don't really care about the formal grammar though, I just care about the number of different syntactic patterns that I need to be able to recognise and comprehend.

[CyrusNajmabadi]

return and => are not synonyms though.

[canton7]

Presumably this also means that

void Foo() Bar();

void Foo() if (cond)
{
    Bar();
} 

etc all become valid? I really don't like that.

Particularly with local functions:

void Foo()
if (cond) 
{
    Bar();
} 
Baz();

Baz isn't part of the local function, but it sure looks like it is.

[OJacot-Descombes]

I would use this syntax only for one-liners and otherwise use a block body. You have the same decision to make with the if and loop statements. if (cond) Bar(); or if (cond) { Bar(); }. I use a block in most cases, even when they contain one statement. I also put the local functions at the very end of the method block with two empty lines between the method statements and the local functions, otherwise they are hard to discover. It is always possible to write unreadable code. It's up to you.

[canton7]

I recommend researching the "Pit of success", and how it relates to C# language design.

[alrz]

Rust use fn f() -> T { expr } for this. However, this applies to any other block expression (including nested blocks).

A similar feature is championed at #3086 - maybe that could be extended to method blocks for the same effect.