Feature request: coalesce operator to work with tuples' values

[WashingtonARamos]

Make it so that the coalesce operator can check and assign values inside tuples based on values inside other tuples value-by-value.

Ex.:

string a = "a", b = "b", c = "c", d = null;
(a, b) = (c, d) ?? ("foo", "bar");

Would produce a == "c" and b == "bar", that is: the operator checks for value inside c, which isn't null, and assigns it to a; it then checks value inside d, which is null, and assigns "bar" to b.

[MihaZupan]

Looking at the syntax my instinct would say that the NCO would be hit in an OR manner.
As in if any of the elements are null, set them to the NCO's value => if c or d are null, set a to foo and b to bar.
Only clear scenario would be a throw statement on the right side of the NCO, being executed if any element is null.

For the behaviour you're describing, I think it should be written as

(a, b) = (c ?? "foo", d ?? "bar");
// Which is then essentially
a = c ?? "foo", b = d ?? "bar";

[svick]

I think my main problem with this proposal is that it would be confusing.

Consider the following two methods:

(string, string) M1((string, string)? t1, (string, string) t2) => t1 ?? t2;
(string, string) M2((string, string) t1, (string, string) t2) => t1 ?? t2;

Those two methods are quite similar, but behave very differently, and I think that would lead to confusion.

[WashingtonARamos]

Looking at the syntax my instinct would say that the NCO would be hit in an OR manner.
As in if any of the elements are null, set them to the NCO's value => if c or d are null, set a to foo and b to bar.
Only clear scenario would be a throw statement on the right side of the NCO, being executed if any element is null.

For the behaviour you're describing, I think it should be written as

(a, b) = (c ?? "foo", d ?? "bar");
// Which is then essentially
a = c ?? "foo", b = d ?? "bar";

Your syntax really makes a lot more sense and right now I see how bad my syntax would be and how much code smell could be created with it.

[Austin-bryan]

@MihaZupan

That was exactly my first instinct. Given the grouping nature of tuples, it makes more sense this way and doing it the other way would be inconsistent.