Champion "conditional ref operator" (C# 7.2)

[gafter]

• Proposal added
  (https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.2/conditional-ref.md)
• Discussed in LDM
• Decision in LDM
• Finalized (done, rejected, inactive)
• Spec'ed

See also

• Proposal: Add support for ternary ref expression roslyn#16473 (original spec)
• Implemented ref conditional operator (aka: ternary ref) roslyn#17436 (prototype)
• The most up-to-date description of the feature (as implemented in C# 7.2) is a part of the following document:
  https://github.com/dotnet/csharplang/blob/master/proposals/csharp-7.2/readonly-ref.md

The idea would be to support a version of the ?: operator that yields an lvalue. The current proposal is to do so using ref after the : and ?, for example

   (array1 != null ? ref array1[index] : ref dummy) = value;

   ref Node next = ref (node != null) ? ref node.Next : ref head;

[VSadov]

@DavidArno - this was discussed:
Proposal: Add support for ternary ref expression

The proposal predates dotnet/csharplang, so it has not been moved to this repo yet.

[DavidArno]

@VSadov,

Ah cool, thanks.

[VSadov]

There is also a PR with implementation. -
Implemented ref conditional operator (aka: ternary ref)

It is a relatively small feature. Basically a left over from the "ref returns".

[gafter]

@DavidArno This feature appeared in literally every example in the original feature request for ref locals and ref returns, but wasn't included in C# 7 along with the feature.

[lachbaer]

   (array1 == null ? ref array1[index] : ref dummy) = value;

Shouldn't it be array1 != null, or is my understanding of this feature wrong?
The reference to value cannot be stored in array1[index], if array1 doesn't exist...?!

[yaakov-h]

How about null-conditional expressions, e.g. ref array1?[index] ?? ref dummy? Would that be possible?

[gafter]

@yaakov-h I don't understand your proposal, but in any case it is certainly a different feature request than this one. If you're requesting a different feature please open a new issue for that.

[alrz]

Can we do this instead?

ref (array1 != null ? array1[index] : dummy) = value;
ref Node next = ref (node != null ? node.Next : head);

[VSadov]

@alrz - it would imply that (array1 != null ? array1[index] : dummy) is an LValue, which it is not.

That is easily observable if the expression returns a struct and you call a mutating method on it -
(array1 != null ? array1[index] : dummy).Mutate() - will not propagate mutations to the operands.

If the expression is supposed to be an LValue only as a part of ref assignment, then there is a need for more rules to figure when ternary is an LValue and when it is not, while being very careful with compat.
It gets more complicated when nested cases are considered.

And that is only to save typing one ref in a feature whose target audience often values explicitness.

[alrz]

I'm proposing that ref make it an lvalue if all branches are lvalue, same applies to other branching expressions as well,

ref (e1 ?? e2)
ref (e match { case P1: e1; case P2: e2; default: e3; })
ref (e1 ? e2 : e3)

Repeating ref on every branch AND the whole construct just seems redundant, IMHO.