Proposal: Default-or-Empty Coalesce operator "???"

[richardtallent]

Default-or-Empty Coalesce Operator "???"

• Proposed
• Prototype:
• Implementation:
• Specification:

Summary

Add a new operator ??? to coalesce either a null or an "empty" value to some other value.

Motivation

The null-coalescing operator ?? is of limited use with strings, because in many cases the logic should treat either a null or an empty string the same way. While String.IsNullOrEmpty() provides a useful method to test these states together, the syntax leaves something to be desired. For example:

var bar = string.IsNullOrEmpty(foo) ? "baz" : foo;

Also, the ?? operator offers no utility for value types that, while not nullable, have a default(T) that should be replaced with a more suitable value when found. DateTime is an excellent example:

var startDate = (oldSubscriptionEnd==default(DateTime)) ? DateTime.Today : oldSubscriptionEnd;

Detailed design

For string objects, the proposed ??? operator returns the left-hand operand if the operand is not null and is not empty; otherwise it returns the right hand operand. E.g.:

var bar = foo ??? "baz";

For value type instances, ??? operator returns the left-hand operand if the operand is not equal to default(T); otherwise it returns the right hand operand.

var startDate = oldSubscriptionEnd ??? DateTime.Today;

For Nullable<T> instances, ??? operator returns the left-hand operand if the operand is not null and is not equal to default(T); otherwise it returns the right hand operand.

Drawbacks

The proposal includes rules for how this operator would apply to other types, but admittedly its primary purpose is to solve a problem specific to strings. In an ideal world, language operators should be generally useful, and there may not be a strong enough case for such an operator for non-string types.

Alternatives

One alternative would be to overload the true, false, and | operators for System.String, allowing a syntax that is very similar to EMCAScript:

var bar = "" || "baz";       // "baz"
var bar = "foo" || "baz";    // "foo"
var bar = null || "baz";     // "baz"

Similar improvements could be made to DateTime and Guid.

Unresolved questions

For non-string reference types, there is no clear answer as to whether the operator should be available, and if so, how it should behave. It could simply be equivalent to ??. Or, for exmaple, a new interface IEmptyable could be created with a single read-only property Empty, which could then be used for the comparison.

Design meetings

This is an individual proposal, I'm not aware of any similar discussions to date.

[ufcpp]

#147

[DavidArno]

As @ufcpp says, this idea has bee suggested before, using the ?? syntax, with the idea that, for the expression:

var x = <item under test> ?? <alternative value>;

Then, if item under test is a class:

1. If null, the alternative value is assigned to x.
2. If not null, and it defines some sort of hasValue property/operator and that returns false, the alternative value is assigned to x.
3. Otherwise item under test is assigned to x.

If it's a struct:

1. If it it defines some sort of hasValue property/operator and that returns false, the alternative value is assigned to x.
2. If that hasValue returns true, item under test is assigned to x
3. Otherwise it's a compilation error.

Whilst ??? could be used to prevent this being a breaking change (and just allowing a simple bool HasValue property to be used, ?? and ??? could be easily confused, so #147 is my preferred proposal.

[jnm2]

What I do for strings specifically is two extension methods:

var bar = foo.NullIfEmpty() ?? "baz";
var bar = foo.NullIfWhitespace() ?? "baz"; // By far the more used

[Rekkonnect]

You can even extend this further and add a DefaultIfWhitespace(string defaultString) extension, which you'd invoke as

var bar = foo.DefaultIfWhitespace("baz");

[richardtallent]

@jnm2, agreed, I have nearly identical extension methods in my arsenal. :)

@DavidArno, the proposals have similarity, but #147 would be incapable of solving this problem for System.String, which was the raison d'être for this proposal. Changing the existing semantics of ?? for strings would be a massive breaking change.

Also, since #147 proposes no changes to existing native types, its use cases could be easily solved by overloading '||' without having to change anything in the language. I'll post an example there for that discussion.

In that case, simply adding a |, true, and false operators to System.String that use the underlying IsNullOrEmpty logic would solve my problem here as well and not require a new operator. E.g.:

public class String {
    public static String operator |(String s1, String s2) => IsNullOrEmpty(s1) ? s2 : s1;
    public static bool operator true(String s) => !IsNullOrEmpty(s);
    public static bool operator false(String s) => IsNullOrEmpty(s);
}

...
string foo = null;
string bar = foo || string.Empty || "bar";    // "bar"
string baz = foo || string.Empty;    // ""

Similar changes to DateTime, Guid and Nullable<T> would close the issue for most other cases where the proposed ??? can't be implemented currently with || because those types are sealed.

[HaloFour]

#164

public extension StringOperators of string
{
    public static string operator |(string x, string y) => string.IsNullOrEmpty(x) ? y : x;
}

[jnm2]

IsNullOrEmpty is not as common as IsNullOrWhitespace for me. We should at least attempt to determine which of the two is more deserving of special operator treatment, if either.

[richardtallent]

@jnm2, I don't have any strong preference, though it seems to me that a string being "empty" is a special state that is analogous to null. In other words, the only reason we even have to distinguish them is because the .NET team chose to implement System.String as a reference type. Meanwhile, logic based on whitespace-only strings seems fairly specific to scrubbing user input or reading legacy fixed-length, space-padded data sources.

I was curious about the relative popularity, here's what I found across all public GitHub repositories:

IsNullOrEmpty - 2,491,375 results
IsNullOrWhitespace - 442,573 results

GitHub's search doesn't allow nailing down which of these is more popular in connection with the conditional operator, which would perhaps be a better gauge of which would benefit more from a shortcut syntax, but at first glance, testing for emptiness seems to be the far more popular option.

[tolbxela]

I work a lot with FoxPro DBs (yep, it's still not dead) and use IsNullOrWhitespace() all the time, since all empty String values coming from FoxPro are padded with space. So I need to .Trim() everything or IsNullOrWhitespace() to check for empty values..

[Rekkonnect]

Next up: the ????? operator, short for "default or null or empty or uninitialized"

[tolbxela]

There is one question mark to much. It should be then ???? for default, null, empty, uninitialized 😄