Idea: coalescing for empty strings or white space

[sliekens]

Hi, I have the following idea to make it easier to work with empty strings or white space.

Pretext

Today, we can write null-coalescing code like this:

void Echo(string? text)
{
    Console.WriteLine(text ?? "no input");
}

Echo("Hello, World!");
Echo("");
Echo("   ");
Echo(null);

Output

Hello, World!

   
no input

Problem

The code above would print the empty strings or white space, but I would like them to be coalesced the same as null. So, I have to use a ternary operation:

void Echo(string? text)
{
-    Console.WriteLine(text ?? "no input");
+    Console.WriteLine(string.IsNullOrWhiteSpace(text) ? "no input" : text);
}

Echo("Hello, World!");
Echo("");
Echo("   ");
Echo(null);

Output

Hello, World!
no input
no input
no input

Idea

Would it be possible to enhance the null-coalescing operator to handle such strings?

For example, ??- for empty strings and ??~ for white space.

WriteLine(text ??- "no input");
WriteLine(text ??~ "no input");

This would also work for assignments:

text ??-= "no input";
text ??~= "no input";

Considerations

In my example, the ternary operation was a simple one-liner, but it can become necessary to introduce a local variable when dealing with calculated strings. Here, a local variable is used to avoid hitting the expensive operation twice:

var text = await CalculateTextAsync();
return string.IsNullOrWhiteSpace(text) ? "no output" : text;

This could be simplified with the operator, to eliminate the local variable:

return await CalculateTextAsync() ??~ "no output";

The ??-= or ??~= might be visually confusing so maybe different characters should be used, or maybe such assignments should not be part of the language.

Finally, it might be undesirable to add an operator that only works for the System.String type, but I'll leave it up to you whether you would open it up for other reference types, or just accept it as an anomaly.

Thanks for your time and consideration.

[HaloFour]

See: #7280 #6584

[TahirAhmadov]

public static T? NullIf<T>(this T This, T value) 
  where T : class 
  => object.Equals(This, value) ? null : This;

[jnm2]

Instead of object.Equals (which boxes), it's recommended to use EqualityComparer<T>.Default.Equals. This is specially recognized by the JIT and specialized for T with the idealized codegen.

(more relevant if you have the matching where T : struct overload)

[TahirAhmadov]

Thanks for the suggestion. I actually use a global using helper method AreEqual<T>(T left, T right) - this helps me avoid bugs caused by calling object.Equals(object, object) and inadvertently boxing/upcasting to object - I've now changed it to call EqualityComparer<T>.Default.Equals.

[theunrepentantgeek]

If such an operator were to be created, what definition of whitespace should it use?

Is ' ' (a single space) whitespace?
Are " " (multiple spaces) whitespace?
Is \t (a tab) whitespace?
What about \n' (a line feed) whitespace?
Is this true even when running on a Windows system?
What about \r\n (carriage return + linefeed)?
Is this true even when running on a Linux system?
What about \x200A (a hair space)?
And so on.

The decision about what whitespace means isn't a constant - it varies from project to project, according to the needs of that project. In other words, it's a matter of policy.

Any definition of whitespace that got baked into the language would necessarily fit some uses, and not others by definition.

A helper method, as suggested by @TahirAhmadov, gives you the policy you need for your project without imposing anything on others.

[yaakov-h]

What is or is not whitespace is already defined by the runtime.

[colejohnson66]

This sounds like an XY problem. Why is CalculateTextAsync() returning an empty string to indicate no result? If a computation has no result, null seems like the better option. Then you could await CalculateTextAsync() ?? "no result".

[sliekens]

You'll still have the same problem, you only moved the responsibility to check for empty strings or white space from client code to the calculation itself.