Pattern matching on method params

[jdavid1385]

Background and motivation

Often times when dealing with methods that would go through a set of switch cases, we end up creating helper methods to react to each one of the possibilities:

public enum Switcheable
{
    S1,
    S2
}
public void Do(Switcheable s)
{
    switch(s)
    {
       case Switcheable.S1:
           DoS1();
           break;
       case  Switcheable.S2:
           DoS2();
           break;
    }
}

API Proposal

What about introducing pattern matching on params?

public void Do(Switcheable s?) when s is S1 {...}
public void Do(Switcheable  s?) when s is S2 {...}
public void Do(Switcheable s?) when s is null {... I know this needs much refinement }

The compiler would convert this into something more like the original example with cases.

API Usage

As in the proposal. But also generalizing to all sorts of available pattern matchers

public void Do(int x) when x>2 { }

Alternative Designs

No response

Risks

You tell me :)

[ghost]

I couldn't figure out the best area label to add to this issue. If you have write-permissions please help me learn by adding exactly one area label.

[HaloFour]

See: #1468

[jdavid1385]

Thank you for the reference. I still don't quite feel the motivations are the same but feel free to close this one.

[DavidArno]

At the risk of going off at a tangent, I'd far prefer C# adopted something akin to F#'s "pattern matching functions", so I could write something like:

public void Do(Switcheable s) => {
    Switcheable.S1 => DoS1(),
    Switcheable.S2 => DoS2(),
    ...
};

[HaloFour]

Not really that different from a method with a switch expression body. I'd argue that it works better with methods with multiple parameters, too, although I guess you could implicitly treat them as a tuple.

[DavidArno]

Not really that different from a method with a switch expression body

Absolutely. If F#, function is just a short-hand way of avoiding having to specify match x with in pattern matching function. The same would be achieved here: it save a small amount of typing. Of course in F#, pattern matching functions are common, so that short-cut is justified. Whilst I write a lot of functions with switch expression bodies in C#, I'm not sure how common the practice is. So it's maybe less justified here.

In fact, rather than taking this discussion off on a tangent, I'll create a new one to record this idea. It's unlike to gain traction (yet), but there's no harm in recording it.

,,, although I guess you could implicitly treat them as a tuple

That was my thinking. I'm write that up too.

[DavidArno]

Idea posted to #6916.