Extension types and type-testing for active patterns

[Richiban]

Apologies if the title is confusing, but I'm wondering if we can leverage roles/extensions with pattern matching to get, effectively, active patterns.

Here's what I mean; the language has, to an extent, painted itself into a syntactic corner a little bit around pattern matching and deconstruction, in that deconstruction currently cannot fail without throwing an exception and it's not possible to have named deconstructors, since deconstruction requires the name of the method be Deconstruct. This means an entirely new construct will have to be developed to implement active patterns (i.e. patterns that the user can define and have control over both deconstruction and whether or not the patterns succeeds or fails).

If the language expands pattern matching slightly so that Deconstruct can return a bool, that at least allows us to define fallible patterns. We might then be able to use roles to fill in the presence of named deconstructors, e.g.

public void M(string s)
{
    // We want to ascertain whether a string matches a given regex in a switch statement and, if it does, get a variable containing the captures
    switch (s)
    {
        case MatchRegex("a(b)c") captures:
            Console.WriteLine(captures[0]);
            break;
        ...
    }
}

// We could do this by defining an extension on string that allows us to write a deconstruction method *and* have the name of a type
public extension MatchRegex for string
{
    public bool Deconstruct(string pattern, out object[] captures)
    {
        // Impl not important for this example
        ...
    }
}

I think this fits quite well since MatchRegex is a type name and it goes in the pattern syntax where a type would normally be: if (s is MatchRegex(".+") captures). Let me know your thoughts.

[HaloFour]

Extension methods for user-defined positional patterns would be interesting.

There have been conversations on Discord recently that the team is very interested in having pattern matching work with extensions. In that case it has been more of a question of matching the underlying type to the extension type where you'd want to apply some validation. In this situation the pattern would behave more like a type pattern, but at that point I don't see why normal deconstruction wouldn't work.

More interestingly would be what kind of changes would be required in the language to enable inputs to patterns. That's something I've hoped would be added to support general purpose active patterns, like regex.

[DavidArno]

More interestingly would be what kind of changes would be required in the language to enable inputs to patterns. That's something I've hoped would be added to support general purpose active patterns, like regex.

I guess that hinges on what it means to have a constructor for an extension type:

public extension MatchRegex(string pattern) for string
{
    public bool Deconstruct(out object[] captures)
    {
        // Impl not important for this example, but uses the pattern constructor parameter
        ...
    }
}

And then, at the risk of bike-shedding, we maybe have something like:

switch (s)
{
    case MatchRegex("a(b)c")(captures):
        Console.WriteLine(captures[0]);
        break;
       ...
}

where MatchRegex("a(b)c") is an extension of string with the pattern "a(b)c" and a single-element deconstruct that can access that pattern.

[FaustVX]

Why did you added the pattern parameter in MatchRegex ?
What's the difference between the pattern and this inside the extension ?

[DavidArno]

The OP's idea doesn't need the extensions as it could be achieved without them:

public static class StringExtensions
{
    public bool Deconstruct(this string source, string pattern, out object[] captures) { ...
}

...
switch (s)
{
    case string("a(b)c") captures:
        Console.WriteLine(captures[0]);
        break;
    ...
}

Allowing an input field into a deconstruct to support non-constant patterns has been discussed at length, but the language team don't seem very interested. They may change with extension types, but it seems unlikely. But constructors for extension types have been talked about and that could provide a way of achieving non-constant/active patterns.

[HaloFour]

I don't think it was a lack of interest as much as it would be a fairly big redesign:

dotnet/roslyn#9005 (comment)

It didn't seem like Neal had closed the door to that conversation, but that was 8 (😱) years ago.