Proposal: Null propagating short-circuiting arguments

[AlexanderMorou]

Null Propagating Short Circuiting Arguments

Summary

The ability to short-circuit a method-invocation in the event a specific argument is null.

Proposal

Take the following code which checks the arguments into a method prior to executing a call:

if (format != null && args != null)
    Console.WriteLine(format, args);

Using short-circuiting arguments the code could be simplified to the following:

Console.WriteLine(?? format, ?? args);

Considerations

If the short-circuited argument is non-nullable, it would be incorrect to perform the operation against that parameter.

Evaluation with respect to Coercion

If there is an implicit operator which converts a type A, to a type B, it would need applied before the short-circuit operation. As a result it may impact the above consideration if the type A was a struct, and type B is a class, in the event that the implicit conversion yielded a null value.

Syntax

The syntax change would be fairly simple:

argument_value
    : '??'? expression
    | '??'? '<|'
    | 'ref' '??'? variable_reference
    | 'out' variable_reference
    ;

The '??'? '<|' is derived from the #96 : Proposal Pipe-Forward operator

It wouldn't be allowed on the out parameter because it's implicitly unassigned within the scope of the called method, so it wouldn't really make sense.

Scope

The scope of the short-circuit would be to the immediate consumer of the result expression. For example:

Console.WriteLine(string.Join(?? separator, ?? values)));

Console.WriteLine would be invoked each time. string.Join would be skipped and a default(string) would be placed on the stack if either separator or values are null.

This would also likely require a variable for each parameter passed into the target of the method invocation, even for those which are not short-circuited. Rationale: maintaining order in which the operations are performed is paramount to avoiding altering the resulted code's behavior.

The caller of the method would need to understand the implications of using the short circuiting.

For instance:

Console.WriteLine(Method(A, ?? B, C, ?? D, E, F, ?? G));

Due to the notion of it being a short-circuiting behavior, if B was null, expressions A and B would be the only two expressions evaluated; however if B is non-null and D is null, expressions A, B, C, and D would be evaluated. If B and D are non-null and G is null, then all expressions would be evaluated, but Method would not be invoked.

As such, the above method call would be equivalent to:

T result = default(T);
var a = A;
var b = B;
if (b != null)
{
  var c = C;
  var d = D;
  if (d != null)
  {
    var e = E;
    var f = F;
    var g = G;
    if (g != null)
    {
      result = Method(a, b, c, e, f, g);
    }
  }
}
Console.WriteLine(result);

If the result of the method is not nullable, it would need to be translated into a nullable type, and the result would then be the default(T?) in that scenario. The rationale here is there would be no way do 'know' if the short circuiting occurred with a value type otherwise.

[HaloFour]

See #433

[AlexanderMorou]

I'm more partial to the double question mark (??) due to a single question mark (?) before a variable reminding me of the java wildcard. I find it interesting that thinking about the Pipe-Forward operator lead to a similar construct. I think the short-circuiting naming convention is more accurate, though.

Perhaps naming it Null Short Circuiting Arguments is more appropriate.