Proposal: pattern matching of states

[Ultrahead]

From C# 7 and on, you can write code like the following:

switch(myStruct)
{
   case MyStruct myStructTemp when (myStructTemp.Equals(myOtherStructOfSameType)):
       ...
       break;
      ...
}

The idea is to allow a shortcut, like:

switch(myStruct)
{
   case myOtherStructOfSameType:
       ...
       break;
      ...
}

I must admit that I thought of this mainly for structs, but it could be extended to other types.

[jnm2]

I've wanted this for arbitrary types a couple of times.

[Ultrahead]

Any news on this? Is it being considered?

[HaloFour]

This would be effectively matching against arbitrary values rather than constants, no? I don't see what it has to do with "state".

[Ultrahead]

This would be effectively matching against arbitrary values rather than constants, no? I don't see what it has to do with "state".

"An object is an entity that has state, behavior, and identity ..."

[MadsTorgersen]

Thus far we've held to patterns being independent of enclosing state. It means that we can reason about exhaustiveness and reachability in switch statements and expressions, for example. I also think that it is a nice property for users to be able to trust: That a given pattern applied to the same value gives the same result.

I do see the utility of comparing to a computed value, but I'd be hesitant to sacrifice the invariants around patterns to allow it as a shorthand.

[svick]

@MadsTorgersen

It means that we can reason about exhaustiveness and reachability in switch statements and expressions

switch already supports when. How does this proposal prevent that reasoning any more than when already does?

[Ultrahead]

I do see the utility of comparing to a computed value, but I'd be hesitant to sacrifice the invariants around patterns to allow it as a shorthand.

Maybe it could be achieved without modifying the logic of and invariants of pattern matching (?)

Since there would be no need to create a new variable in the case of same-type structs, maybe ...

switch(myStruct)
{
   case myOtherStructOfSameType:
       ...
       break;
      ...
}

... could be translated into:

if(myStruct.Equals(myOtherStructOfSameType)
{
}
else if (...)
{
   ...
}

[giggio]

This is important. I understand @MadsTorgersen point about exhaustiveness, but @svick's point about when is also relevant. When a when is present, you can't be sure if a pattern matching was exhausted or not. You can reason that maybe it wasn't exhausted. I guess that is why it is a warning, not an error. The compiler is already warning us if the match was not exhaustive, but it might be wrong. For example, the following code generates the warning (1):

ns switch
{
    var x when x.IsEmpty => 0,
    var x when !x.IsEmpty => 0,
};

And the above code clearly is exhaustive. But I understand the compiler can't reason on the two expressions. As it could not reason on a different pattern.

Enabling expressions instead of only types and constants, would allow me to do the following.

Right now, I have to do this (2):

int Sum(in ReadOnlySpan<int> ns) =>
    ns switch
    {
        var x when x.IsEmpty => 0,
        var (head, tail) => head + Sum(tail)
    };

If expressions were allowed, we could do this (3):

int Sum(in ReadOnlySpan<int> ns) =>
    ns switch
    {
        ReadOnlySpan<int>.Empty => 0,
        var (head, tail) => head + Sum(tail)
    };

Which is much more readable. And right now, on snippet (2), if I remove the last pattern, I already get a warning. This shouldn't change if (3) was allowed.

[svick]

@giggio I'm not sure that code would work the way you want, even if this feature was implemented, because ReadOnlySpan<int> uses something close to reference equality. For example, the following code prints False:

ReadOnlySpan<int> ns = new int[0];
Console.WriteLine(ns == ReadOnlySpan<int>.Empty);

[Ultrahead]

Any news about this proposal? Is it being considred?