Proposal: Regular Expression Pattern Matching

[adamhewitt627]

I think this could already be done in a switch leveraging the when clause, a static method and an out var, but there are some limitations. Essentially, existing syntax allows for:

private static bool _(string input, string pattern, out Match match)
    => (match = Regex.Match(input, pattern)).Success;

switch (value)
{
    case string s when _(s, @"\d+", out var numMatch): /* consume numMatch */ break;
    case string s when _(s, @"\s+", out var wsMatch): /* consume wsMatch */ break;
}

That gets pretty wordy (and I can't verify it even works right now as I write this) but I'd envision something more like:

switch(value)
{
    case new Regex(@"\d+") numMatch: /* consume numMatch */ break;
    case new Regex(@"\s+") wsMatch: /* consume wsMatch */ break;
}

And I know you're probably cringing a bit at that, I am. I'd probably rather not have it than have that syntax. So what I would really envision is two-fold:

1. Compiled regular expressions as part of the language. (I don't plan to write up that proposal unless there's real interest in it or this one - but at the very least it can live separate from this one)
2. Use regex-literals in the switch

switch (value)
{
    case /\d+/ numMatch: ... break;
    case /\s+/ wsMatch: ... break;
}

This would then move top to bottom (like the other pattern-matching switches) comparing value against the regex and dropping into the case where applicable. Some questions for discussion:

1. Should value be forced to be a string, or coerce to a string like in string formatting?
2. The place I wanted this only had one Match to consider, but what about needing a MatchCollection?

[svick]

If F#, this can be done using active patterns. (Though I think active patterns for regular expressions are not part of the standard library.) Your example would translate to something like:

match value with
| Regex @"\d+" numMatch -> …
| Regex @"\s+" wsMatch -> …

I imagine that in C#, the same could be done with user-defined is:

switch(value)
{
    case Regex(@"\d+", var numMatch): … break;
    case Regex(@"\s+", var wsMatch): … break;
}

As long as something like this worked, I don't think C# needs special syntax for regular expressions.

Though I'm not sure how would this work for compiled regular expressions.

[adamhewitt627]

If I understand the user-defined is correctly, that would allow the Regex class to implement:

public class Regex
{
    public static bool operator is(string input, string pattern, out Match match)
    { /* ... */ }
    public static bool operator is(string input, string pattern, RegexOptions options, out Match match)
    { /* ... */ }
    public static bool operator is(string input, string pattern, out MatchCollection matches)
    { /* ... */ }
    public static bool operator is(string input, string pattern, RegexOptions options, out MatchCollection matches)
    { /* ... */ }
}

While I like the idea of regex in the language (especially to have compile-time validation of its syntax) if the is does work this way it addresses:

1. The new was my least favorite part of my middle example above
2. Match vs. MatchCollection is easily handled inline without special logic for the Regex class

[HaloFour]

@adamhewitt627

There was some discussion about patterns like this on the Roslyn repo. One of the issues identified was how the parser could disambiguate between input expressions to such patterns v. constant patterns.

dotnet/roslyn#9005