Champion "Nullable-enhanced common type"

[MadsTorgersen]

• Proposal added: proposals/csharp-9.0/nullable-enhanced-common-type.md
• Discussed in LDM (2017-04-19)
• Decision in LDM (2017-04-19 Approved to proceed with implementation)
• Finalized (done, rejected, inactive)
• Spec'ed

Summary

There is a situation in which the current common-type algorithm results are counter-intuitive, and results in the programmer adding what feels like a redundant cast to the code. With this change, an expression such as condition ? 1 : null would result in a value of type int?.

This and #881 should be taken into the language at the same time.

[scottdorman]

To clarify, the example in the Summary condition ? 1 : null would previously need to be written as condition ? 1 : (int?)null.

In the other example, condition ? new Dog() : new Cat(), you state that it "would result in a value of
their common base type Animal." Is there a way to control this?

For example, what if there were an IAnimal interface they both implemented in addition to the base class, and I wanted the result to be of that interface type rather than the abstract Animal type? Could this be influenced by writing this as IAnimal animal = condition ? new Dog() : new Cat()?

[DavidArno]

What would happen in the following case? Presumably a compiler error as there's ambiguity over which base type to use?

interface IPet {}
interface IMammal {}

class Cat : IPet, IMammal {}
class Dog : IPet, IMammal {}
...
var animal = condition ? new Dog() : new Cat();

Though this could be then solved by doing as @scottdorman suggests:

IPet animal = condition ? new Dog() : new Cat();

[scottdorman]

@DavidArno In your example, there is no common base class so I think a compiler error is reasonable. In that case, you wouldn't be able to use var and would have to explicitly type it to the interface you want.

You could still use var and just cast each piece to the same interface, like

var animal = condition ? (IPet)new Dog() : (IPet)new Cat();

but that defeats the purpose of the proposal.

[alrz]

In your example, there is no common base class

object?

[gafter]

@scottdorman

In the other example, condition ? new Dog() : new Cat(), you state that it "would result in a value of
their common base type Animal." Is there a way to control this?

Yes. You can cast either operand to the common type that you want to be the result.

[scottdorman]

@gafter

Yes. You can cast either operand to the common type that you want to be the result.

So, I'd be able to write this as

var animal = condition ? (IAnimal)new Dog() : new Cat()

but not

IAnimal animal = condition ? new Dog() : new Cat()

That still seems like an unnecessary cast. The fact that I'm strongly typing the variable should be enough for the compiler to know what type it should try to cast Dog or Cat to.

[gafter]

@scottdorman The type of a ?: expression does not depend on the context in which it appears.

[scottdorman]

@gafter Ok. That makes sense. So in my example, the only viable option is to cast one of the operands to the desired type. In that case, it doesn't feel like I've gained any benefit here.

Now, for the first example (condition ? 1 : null), this would let me skip the explicit cast so less typing/clutter in the code, which is good. :)

[alrz]

This is expected to affect the following aspects of the language:

Probably ?? would be also affected.

var animal = obj as Dog ?? obj as Cat; 

[DavidArno]

Looking through the spec of the proposal, it will be a real shame here if the common type were just limited to class types. I would have thought that it would also commonly be the case that the two types share a common interface, but the inheritance common type would be object. In such cases, it would be good to have that interface treated as the common type in such expressions.

[scottdorman]

it will be a real shame here if the common type were just limited to class types.

I tend to agree with that statement. It seems to me, as long as there is an unambiguous common type which can be inferred, that type should be used. If that unambiguous common type happens to be an interface, then that's what gets used. If it's ambiguous for any reason (multiple interfaces, etc.) such that the compiler can't clearly decide then it's a compiler error.

[gafter]

...such that the compiler can't clearly decide...

Whether or not the compiler "can decide" depends on the rules the compiler is supposed to use to decide.

[scottdorman]

Whether or not the compiler "can decide" depends on the rules the compiler is supposed to use to decide.

True, but in the example case where there are two interfaces being implemented:

interface IPet {}
interface IMammal {}

class Cat : IPet, IMammal {}
class Dog : IPet, IMammal {}
...
var animal = condition ? new Dog() : new Cat();

How would the compiler know which interface to use as the common base type? I think in this example, the compiler can't know which one to use and so should raise a compiler error.

However, if we wrote it as

interface IPet {}
interface IMammal {}

class Cat : IPet, IMammal {}
class Dog : IPet, IMammal {}
...
IPet pet = condition ? new Dog() : new Cat();
var animal = condition ? (IPet)new Dog() : new Cat();
IMammal mammal = condition ? new Dog() : new Cat();

Then in the first two instances, the compiler has enough information to know that the common base type is IPet and in the last instance it knows the common base type is IMammal.