Permit ternary operation with int? and double operands

[gafter]

We would like to change the spec for #33 so that this proposed feature also permits the following:

int? ni = 1;
double d = 4;
bool c = true;
var x1 = c ? ni : d;

This is currently an error because there is no implicit conversion between int? and double in either direction.

[bondsbw]

To clarify, is the type of x1 intended to be double? (as the greatest common type) or int? due to flow analysis?

[iam3yal]

@bondsbw yes x1 is intended to be double? as it can't be int? because there's no conversion between double to int or double? to int? and there's no flow analysis done here so the type of var is always one of the types you had to type yourself so the only option left here is double?.

To sums this up, this works:

int? ni = 1;
double d = 4;
double? x1 = ni;
double? x2 = d;

[MgSam]

@gafter I assume this implies lots of other conversions as well?

• short? and double
• short? and int
• int? and long
• etc.

[bondsbw]

How does this play out considering union/intersection types (#399)?

This proposal advocates that the result of a ternary expression is a union type, because double? is equivalent to int? | double.

But as @HaloFour commented here, an intersection type seems reasonable as well. You should only be able to perform operations on the result which are common to both types. The result of var animal = condition ? new Dog() : new Cat() should not allow animal.Bark() since it could be a Cat.

EDIT: after some thought, what I described in the second paragraph is the union type, not intersection.

[MgSam]

I'd say ternary should never make implicitly a union/intersection type but require you to instead be explicit. Implicit behavior is bound to lead to confusion and ambiguity for precisely the reasons you illustrate.

All academic, of course, since the team hasn't shown any interest in the feature.

[bondsbw]

All academic, of course, since the team hasn't shown any interest in the feature.

Perhaps, but implementing this proposal could impact future plans.

[DavidArno]

Definitely with @bondsbw here (and presumably, by implication, @HaloFour too). Such changes as proposed here should be deferred until after any work (or formal rejection) of union and intersection types is complete.

[MgSam]

@DavidArno So stop a nice feature we could have in a few months for the remote possibility of a feature in 5 or 10 years? Sounds like paralysis through analysis.

[DavidArno]

@MgSam,

That really depends on whether one views this as a "nice feature" or not. From my perspective it's a minor niche feature that absolutely should not take priority over a good implementation of union and intersection types. If this change affects you though, and you have no interest in unions and intersections, you'll likely have a very different view on priorities.

[HaloFour]

This proposal only affects a select view value types. I can't imagine that intersection types, if they are ever implemented, will ever support value types, so I'm all for this proposal being implemented today.

[MgSam]

@DavidArno Questions/complaints about the current inability of the ternary operator to handle cases like this (and null propagation) are extremely common on StackOverflow and elsewhere. And I don't know about you but I write ternary operators literally every single day. Granted most of those won't benefit from this sub-feature, but the closer the operator gets to "it just works like you'd expect it to" the better.

[gafter]

How does this play out considering union/intersection types (#399)?

How would you suggest it should play out? Please explain what implications you believe we should be considering, considering that we may or may not ever do them.

[bondsbw]

@gafter I believe I was mistaken that there is a conflict (and I edited that comment).

I'd still like to flesh it out a bit. Generalizing the original example:

int? ni = ...;
double d = ...;
bool c = true;
var x1 = c ? ni : d;

As stated above for #399, x1 would have the union type int? | double. This would be the union set of int? and double.

int? (for practical purposes) is the set

• -2147483648
• ...
• -1
• 0
• 1
• ...
• 2147483647
• null

and double is the set of

• Positive and negative zero.
• Positive and negative infinity.
• Not-a-Number value (NaN).
• The finite set of nonzero values between -1.79769313486232E+308 and 1.79769313486232E+308 which have 52 significand bits and 11 exponent bits (and a sign bit).

Since double contains all values in int, then int? | double is the set of values in double plus the value null... in other words, double?.

So the issue is the idea that int? | double automagically becomes double?. (Not saying that's bad in any way, but just thinking about implications to the design.)

[bondsbw]

Consider another case:

sbyte? sb = ...;
byte b = ...;
bool c = true;
var x2 = c ? sb : b;

x2 has the type sbyte? | byte. There is not an exact equivalent type that is built in. I think the closest superset is short?. So does x2 have the type sbyte? | byte or short??

EDIT: separated into another comment

[gafter]

The spec has been changed by #1806 as requested.

So this would now be included in the championed issue #33

[gafter]

This should be done (if at all) at the same time as #2473 and #2460.

[gafter]

See also #881