Proposal: Overridable default operator

[orthoxerox]

As previously seen on dotnet/roslyn#71

Problems

1. When we get non-nullable reference types, what happens when we write var os = new object[10] instead of var os = new object?[10]?

2. When we get value types with parameterless constructors, symmetry between default(T) and new T() gets broken for them.

Solution

We should be able to override operator default. Yes, this means that default will no longer be always emitted as ldnull or ldloca - initobj - ldloc and any newarr will be followed by a loop.

However, with CLR support this could be optimized for cases where a single static instance is returned by the overridden operator.

[HaloFour]

What happens with var os = new T[10]? Or with fields of a struct? There are so many ways through which this mechanism could be easily and accidentally defeated.

[DavidArno]

@HaloFour,

At the risk of sounding like a stuck record: that's why features such as this needs CLR support. var os = new T[10] should invoke T's overridden default operator, ten times, to create a properly initialised os.

Of course the killer counter to this is that the CLR team are unlikely to countenance the decrease in performance that such checking for an override would incur. So I may be left sounding like a stuck record until I finally shut up 😀

[lachbaer]

How do you solve the problem of a valid "default" fraction?

struct Fraction {
    double numerator;
    double denominator;
    Fraction() {             // error!
        numerator = 0;
        denominator = 1;
    }
    double ToDouble() => numerator / denominator;
    bool IsValid => denominator != 0;
}

As explicit parameterless constructors are not allowed for structs something like a default operator would really come in handy here!

I believe there are plenty of situations out there where the definition of a "default value" with appropriate operators would make much sense in respect to data coherance.

[DavidArno]

@lachbaer,

To continue sounding like a stuck record, just allowing parameterless constructors won't help for your Fraction struct, as calling default(Faction) will still give me a 0 denominator. Thus this proposal: calling default(Faction) would result in its own default method being called, so that the denominator can be set to a sane value.

[jnm2]

@DavidArno In my opinion, there is no sane default value for the numerator and denominator of a fraction. Far better would be forcing new Fraction(n, d), preventing default(Fraction) and preventing the parameterless constructor, which also means preventing creating arrays without giving an initial value for each element. Etc.

I think default(T) should always mean zeroed bytes as it always has, and you should rely on a constructor for anything else.

[lachbaer]

Because it has not been mentioned here explicitly. This proposal is directly related to #99.

[jnm2]

Update: because of the no-arg struct constructor discussion, I would not mind having default(T) be allowed to do constant pattern-fill since that can be nearly as efficient as zero-fill.

Perhaps something like this:

struct FractionWithArbitraryDefaults
{
    public readonly double Numerator;
    public readonly double Denominator;

    public FractionWithArbitraryDefaults(double numerator, double denominator)
    {
        Numerator = numerator;
        Denominator = denominator;
    }

    // Metadata that specifies pattern- *not* code that will be executed to create the pattern
    default { Numerator(0), Denominator(1) }
}

Constant (blittable) default initialization makes sense. Executing arbitrary code X times however does not make sense for default.

default(X) means "give me the value that a class field or array would be initialized with if a user constructor was not executed." By the very name default and its purpose in the C# language, default(X) should provide the exact same result you'd get if you did this:

Default<int>.Value
Default<object>.Value
Default<MyStruct>.Value

static class Default<X>
{
    public static readonly X Value;
}

Never should that code result in executing user constructor code. That is what default(X) is all about.