Champion "Pattern Matching" (16.3, Core 3)

[gafter]

• Proposal added: proposals/patterns.md
• Discussed in LDM
• Decision in LDM
• Finalized (done, rejected, inactive)
• Spec'ed

Update: We take this to represent recursive patterns and match expressions. Active patterns should be tracked separately, as they won't happen at the same time.

LDM notes:

• https://github.com/dotnet/csharplang/blob/master/meetings/2017/LDM-2017-11-29.md
• https://github.com/dotnet/csharplang/blob/master/meetings/2018/LDM-2018-04-30.md
• https://github.com/dotnet/csharplang/blob/master/meetings/2018/LDM-2018-05-02.md#revisit-syntax-for-switch-expression
• https://github.com/dotnet/csharplang/blob/master/meetings/2018/LDM-2018-10-24.md#pattern-matching-open-issues
• https://github.com/dotnet/csharplang/blob/master/meetings/2018/LDM-2018-11-05.md#pattern-matching
• https://github.com/dotnet/csharplang/blob/master/meetings/2018/LDM-2018-11-14.md#switch-exhaustiveness-and-null
• https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-01-09.md#ambiguities-in-nullable-array-types-again (syntactic ambiguities, trailing commas)
• https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-03-06.md#pure-checks-in-switch-expression (pure tests)
• https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-03-13.md#precedence-of-the-switch-expression (precedence, or, pure null tests)
• https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-04-22.md#target-typed-switch-expression (target-typed switch expression)
• https://github.com/dotnet/csharplang/blob/master/meetings/2019/LDM-2019-07-10.md (empty switch statement)

[DavidArno]

Sad to see this slip, yet again, from 7.1 to post 7.2. Please can we have it soon.

[gordanr]

@alrz You have very nice, simple and powerful proposal in Roslyn repository.
Proposal: Negative Pattern #16766.
Maybe you could reopen that theme here.

[alrz]

@gordanr Filed issue: #246.

[alrz]

didn't see that coming. http://cr.openjdk.java.net/~briangoetz/amber/pattern-match.html

[DavidArno]

Since I can see the implementation of the other 80% of pattern matching in C# slipping out to beyond v8 (due to the team being so focused on "improving" interfaces at the moment), it wouldn't surprise me if Java gets this stuff before C# does. 😞

[HaloFour]

@alrz

I did. Java 8 made it a warning to use _ as an identifier. In Java 9 it's illegal. I totally expected that to open the path to wildcards in patterns.

@DavidArno

The C# team could push proper pattern matching out to C# 11 and they'd still likely beat Java to the punch. But I expect that the C# team can actually work through interfaces and patterns at the same time, especially since a lot of the groundwork for the latter has been laid and a lot of the work of the former relies on an external team.

It'll be interesting to see where Java goes with the open questions, particularly since they recognize the same scoping issues that the C# team had to work through.

[alrz]

Java 8 made it a warning to use _ as an identifier.

Thank god they do not do fallback-binding thingy. I wonder why C# is reluctant to take such changes. var should've been a keyword by now. I'd prefer warning-waves cripple my build rather than being another compiler flag. That's another example of how C# deals with these changes in a non-breaking way and it does no good for the remaining +80% of users who do not suck.

[DavidArno]

@HaloFour,

I have now stuck a postit note to my monitor that says, in big bold letters, "STOP MOANING ABOUT INTERFACES; YOU ARE BORING EVERYONE". Let's see if I can follow its advice...

[orthoxerox]

@alrz The other 20% users probably account for 80% of MSFT's DevDiv revenue.

[alrz]

@orthoxerox C++ also did this for auto. C# does not have a bigger audience than those languages.

[HaloFour]

@alrz

It's not the first time that Java has broken compatibility. When Java adds a keyword it's not done contextually. It's pretty rare when it happens. I think the last time was Java 5 and assert.

Java 9 will be an interesting experiment. They've been pretty open that this release will potentially break a lot of code, for two major reasons. First, modules, which finally bring a degree of non-visibility to public/protected members, even through reflection. Second, they're finally going to finally remove a bunch of APIs that have been marked deprecated for a very long time. The removal of _ as a valid identifier is peanuts in comparison.

If the pain proves to be too much I could see Oracle pulling their punches going forward, perhaps even regressing a bit in a point release.

[gafter]

A prototype of the latest pattern-matching stuff is available at https://github.com/dotnet/csharplang/wiki/vNext-Preview

[philn5d]

I looked for quite some time where to comment and landed here.

Related to this:

https://github.com/dotnet/csharplang/blob/master/proposals/patterns.md

Which I believe is related to "Recursive Pattern" in this msdn blog post about C#8:

https://blogs.msdn.microsoft.com/dotnet/2018/11/12/building-c-8-0/

Which shows the following example:

IEnumerable<string> GetEnrollees()
{
    foreach (var p in People)
    {
        if (p is Student { Graduated: false, Name: string name }) yield return name;
    }
}

Wouldn't it be much more concise to allow:

IEnumerable<string> GetEnrollees()
{
    foreach (Student { Graduated: false, Name: string name } in People)
    { 
        yield return name;
    }
}

and even:

IEnumerable<string> GetEnrollees()
{
    foreach (Student { Graduated: false } as student in People)
    { 
        yield return student;
    }
}

In both cases, only People of type Student with property Graduated == false should be selected. In the first example, Name should also not be null.

In the first example, Name should be assigned to a string variable name.
In the second example, the current Student instance should be assigned to the variable student. The "as" keyword indicates the assignment.

It should be possible to combine as follows:

IEnumerable<string> GetEnrollees()
{
    foreach (Student { Graduated: false, Name string name, StartDate DateTime startDate } as student in People)
    { 
        if(CheckName(name) && startDate < today) yield return student;
    }
}

[HaloFour]

@philn5d

As you're suggesting new syntax I would suggest opening a new issue.

[munael]

@HaloFour , https://github.com/dotnet/csharplang/blob/master/proposals/patterns.md is a 404.

As it stands, it's not really clear what syntax this issue is tracking.

There's a trail of public and LDM discussion history but they mention different parts of things related to pattern matching. It's just not clear what the current idea is.

[alrz]

It's moved to https://github.com/dotnet/csharplang/tree/master/proposals/csharp-8.0 as the feature is marked for the release.