Pattern matching syntax for non-constant values

[Grovre]

Currently, pattern matching is a neat and extremely easy way of expressing conditions for a variable against constants. For example:

if (_array.Length is >= 0 and < 100)
{
    // ...
}

However, the pattern matching syntax is not valid when non-constant values are used in place of the constants. For example, this will not work:

int min, max;
// Find dynamic range
// ...
if (_array.Length is >= min and < max)
{
    // ...
}

Instead, it will look like:

int min, max;
// ...
if (_array.Length >= min && _array.Length < max)
{
    // ...
}

Code using non-constant values with pattern matching expressions will:

1. Flow naturally
2. Be concise
3. Improve understanding of complex logic

Along with all other reasons the existing pattern matching syntax was introduced, the three listed reasons will correlate with things like reducing developer errors in logic and improving maintainability. The syntax would be a quality factor for developers.

[huoyaoyuan]

See also #4321 and #6947

[bzd3y]

Is this really a fit for pattern matching, though? I think that implies that the thing being matched is a constant/literal of some kind. Arguably something that changes, like a variable, might not really create a "pattern". For example, what happens if min is greater than max? With a constant/literal the compiler can produce an error that the given pattern can never be matched, but with a variable (at least one that it doesn't know never actually changes) it can't do that. Of course, it can't catch that error with the existing method either. But it seems like one of the intents for pattern matching is that it can. Again, if it can't, then it arguably isn't a pattern.

I do like this idea, but it seems like it might make more sense to use a "trinary" operator that is syntactic sugar for the binary operator form and would keep the direction of the operators the same/consistent. So something like:

if (_array.Length >= min && _array.Length < max)
{
    // ...
}

// becomes:
if (min <= _array.Length < max)
{
    // ...
}

You can still cause the error with min being greater than max, but there's no implication that you could avoid it.

[Grovre]

It's not pattern matching, it is just allowing the syntax or something similar to express conditions for non-constant. The min/max issue exists for normal boolean expressions and should behave the same both ways. I like the ternary range idea though.

[bzd3y]

Well, that was based off of what you made the title of the discussion, but also if it uses is then it is probably pattern matching or will look too close to it.