Which kind of pattern matching is this ?

[a510]

The code below compiles successfully although it doesn't look like any of the documented kinds of pattern matching, also why does the compiler requires a destructor for the Foo type ?!

I expected that this code will simply extract the value of the constant expression (double)i into the variable f.

class Program
{
    static void Main()
    {
        Test(new Foo());
    }

    static void Test(Foo o)
    {
        const int i = 1;
        if (o is ((double)i) f)
        {
        }
    }

    class Foo
    {
        public void Deconstruct(out double d)
        {
            d = 1;
        }
    }
}

[svick]

So, the confusing part here is ((double)i). The language understand this as a positional pattern, which can be used to deconstruct tuples, or other types that have the Decontruct method. A more common use of such pattern would be something like var tuple = (1, 2); if (tuple is (3, 4)) ....

The only subpattern of the positional pattern is the constant pattern (double)i. A more common use of a constant pattern would be double x = 1.0; if (x is 0.0) ....

Though it does look confusing, so I wouldn't suggest you actually write such code and I can't think of a situation when you would want to anyway.

[a510]

Thank you @svick, I know this is a terrible code I was just wondering what did the compiler confuse it with.
Do you think the compiler should show a compile error instead ?