Champion: Switch expression as a statement expression

[gafter]

I propose that we support a switch expression as a statement expression when every arm's expression is also a statement expression. No common type among the arms is required when used as a statement expression.

void M(bool c, ref int x, ref string s)
{
    c switch { true => x = 1, false => s = null };
}

Meeting notes

https://github.com/dotnet/csharplang/blob/main/meetings/2022/LDM-2022-08-31.md#switch-expression-as-a-statement

[DavidArno]

Just to check, since I get confused between statement expressions and expression statements, will the following syntax by valid with this proposal:

void M(bool c, ref int x, ref string s) => c switch { true => x = 1, false => s = null };

[Mteheran]

Is the operator for default case still the same for this scenario or this new feature??

As I understand underscore is the current operator

void M(bool c, ref int x, ref string s) { c switch { true => x = 1, false => s = null, _ => x=0 }; }

[dsaf]

Together with exhaustiveness checks this will render existing switch statement pretty much legacy?

[CyrusNajmabadi]

@dsaf how so? You still can't have things like blocks/multi-statements in an expression-form switch.

[dsaf]

@CyrusNajmabadi well maybe initially but those could be added going forward.

[alrz]

Together with exhaustiveness checks this will render existing switch statement pretty much legacy?

Non-exhaustive switches can't be written via switch expression,

void M(string s) {
    switch (o) {
        case 1: s = "A"; break; 
        case 2: s = "B"; break;
    }
}

Unless this is allowed

void M(string s) {
    o switch { 1 => s = "A", 2 => s = "B" };
}

(You still need to repeat the assignment.)

[CyrusNajmabadi]

@CyrusNajmabadi well maybe initially but those could be added going forward.

In that case, they do not "render existing switch statement pretty much legacy". :)

[Thaina]

What happen to

var a = c switch { true => x = 1, false => s = null };

?

[DavidArno]

@Thaina,

It seems sensible that it'll give you a error CS0815: Cannot assign void to an implicitly-typed variable

[Thaina]

@DavidArno We actually could write this

int x = 0;
var a = x = 1; // a is int

And in the next C# I think we could possible to

var a = condition ? 1 : null; // a become Nullable<int>

So actually I expect that it might be possible to

var a = c switch { true => x = 1, false => s = null };
// a become Nullable<int> or object or (int | string)
// then assign both x and a to 1 if true else assign both s and a to null

So I just ask to make sure

[yaakov-h]

If s is a string, then you get error CS8506: No best type was found for the switch expression.

If s is a Nullable<int>/int?, that already compiles, and I see no reason why that would change.

[Thaina]

@yaakov-h It possible that it's behaviour could be CS0815 as @DavidArno speculate. Or maybe other. That's why I ask to make sure what it really would be

As for me I hope that we should support union type and could let this syntax return union type. Or just plain object

[DavidArno]

@Thaina,

The value of, c switch { true => x = 1, false => s = null };, isn't ?int though; it's void. Just as I can write,

void Foo() {}
void Bar() => Foo();
void Baz()
{
    var x = Foo(); // results in error CS0815: Cannot assign void to an implicitly-typed variable
}

So the same should be true of a statement expression switch expression,

void Bar(bool c, ref int x, ref string s) 
    => c switch { true => x = 1, false => s = null }; // all good
void Baz(bool c, ref int x, ref string s)
{
    var a = switch { true => x = 1, false => s = null }; 
    // results in error CS0815: Cannot assign void to an implicitly-typed variable
}

[Thaina]

@DavidArno

c switch { true => 1, false => null };

This expression should be int? though. So

var a = c switch { true => 1, false => null }; // a is int?

Given that

var a = x = 1; // a is int

Expression x = 1 itself is int, not void. So even if we put it in switch it should still be int

C# also already has the ability to ignore any return type to void with => syntax

int Bar() => 0;
void Foo() => Bar();

So I don't think we need to limit switch expression to be void

[DavidArno]

@Thaina,

Sure, var a = c switch { true => 1, false => null }; should reasonably be expected to result in a being a ?int under proposals to support var a = c ? 1 : null;. But that's completely different to:

c switch { true => x = 1, false => s = null };

where x = 1 and s = null are statement expressions (ie have the "value" of void) and thus this proposal to allow the whole switch expression to be treated as a stament expression (ie have the "value" of void).

[CyrusNajmabadi]

I'm not certain what was unclear about my last post. If you want to discuss meta points like these, start a new discussion

[oliverjanik]

This would be super handy in unit tests with most Assert methods being void when testing polymorphic returns.

result switch
{
    int i => Assert.Equal(i, 5),
    string s => Assert.Equal(s, "x"),
    _ => Assert.Null(result),
}

[jsmarsch]

@Pilchard123 returning discard seems fitting for noop branch like (Behaviour.NoOp)=>_, which would read as discard this branch

I like that idea. Viewing the switch statement as a state machine, it makes sense that I would sometimes want to execute code that does not have a return statement.

[ccarlo88]

This would be super handy in unit tests with most Assert methods being void when testing polymorphic returns.

result switch
{
    int i => Assert.Equal(i, 5),
    string s => Assert.Equal(s, "x"),
    _ => Assert.Null(result),
}

Yeah, the issue that you mention looks different to me. First, why don't you use "typeof" to determine what type you are evaluating? Then you use a switch case.
I still look at the request here and it makes no sense (the original one).

[alexrp]

First, why don't you use "typeof" to determine what type you are evaluating?

Can you demonstrate how typeof helps in that example?

[ccarlo88]

Maybe I misunderstood that creepy thing... What it does look to me is receiving a generic T, and depending on T type it process something on that type.... am I wrong? Anyway, this is really creepy, looks like the typical Python crap.

[CyrusNajmabadi]

@ccarlo88 Switch expressions receive a value and allow patterns to match against it. That's been in the language a while now. This issue is the request for allowing the args of the switch expression to be void expressions, and for the switch expression to be considered a legal statement-expression (like Assert.Equal is).

[CyrusNajmabadi]

@ccarlo88 please keep things on-topic and following the .net code of conduct. WRT the language, the group that designs the language (the LDM) is the same one that has been designing it for 25 years now, with most of the same people involved over all that time.

[CyrusNajmabadi]

@ccarlo88 please keep things on-topic and following the .net code of conduct. If you have feelings beyond that, please take them to some other outlet (a blog or discord channel would be better).

[Pilchard123]

Oh, cool, I was literally just about to ask if this could be unlocked.