Proposal: allow NRTs in patterns

[masonwheeler]

This is a very simple proposal: it's currently a compile error to use a NRT in a pattern-matching expression. (ie. x is MyType?) This should be allowed. The semantics would be that either a null or a MyType would be a valid match for this pattern.

The main value in this is that the successful match could then be assigned to a variable of type MyType?. This is not currently possible; if you say x is MyType mt or null you get a compile error because you can't declare a variable inside an or pattern.

[CyrusNajmabadi]

An initial issue here is the grammar prefix overlap for x is Y? Z vs x is Y ? z : w

[masonwheeler]

Good catch.

That could be solved easily enough in the parser by specifying that a nullable-declaration-pattern (or whatever you want to call it) ends with a "not a :" rule. Virtually every grammar has a way to specify "not-match rules" to deal with exactly this type of ambiguity. I haven't looked at how C#'s grammar is specified, but it almost certainly exists in some form, right?

[CyrusNajmabadi]

I didn't mean this couldn't be specified. I meant that due to the grammar productions having a coming prefix, this can be confusing for people to read.

[masonwheeler]

Ah, I see.

Personally, I don't find a high potential for confusion, for two reasons. First, the same rule I laid out can be applied just as easily by people reading the code: if there's a colon, it's a ternary, but if not, it isn't.

And second, a simple matter of convention. For a nullable type, the ? is affixed directly to the end of the type name, while the ? operator in a ternary expression is set apart by a space. This isn't enforced by the parser, but the convention is pretty well-known, and the Visual Studio auto-formatter does enforce both points of the convention. And even in your own example, you wrote it the way people expect for it to be done.

[TahirAhmadov]

How about: x is null or MyType mt
I mean, if that was made legal as a special rule

[timcassell]

Looks almost like a type union x is (null or MyType) mt.

[jnm2]

This proposal would put the language in an inconsistent state compared to nullable value types, where this syntax is already legal and evaluates to false for nulls:

object o = null;
Console.WriteLine(o is int?); // Prints: False

I don't like the idea of T? meaning "T or null" when it's a reference type and just T other times.

[HaloFour]

NVTs aren't allowed in patterns either:

object o = null;
if (o is int? i) { // error CS8116: It is not legal to use nullable type 'int?' in a pattern; use the underlying type 'int' instead.
    // ...
}