Proposal: Improved record type compatibility

[bondsbw]

As mentioned in the current records proposal, it is possible to maintain binary and source compatibility of record types by including compatible implementations of the constructor and members:

// v1
public class Person(string Name, DateTime DateOfBirth);

// v2
public class Person(string Name, DateTime DateOfBirth, string HomeTown)
{
    // Note: below operations added to retain binary compatibility with v1
    public Person(string Name, DateTime DateOfBirth) : this(Name, DateOfBirth, string.Empty) {}
    public static void operator is(Person self, out string Name, out DateTime DateOfBirth)
        { Name = self.Name; DateOfBirth = self.DateOfBirth; }
    public Person With(string Name, DateTime DateOfBirth) => new Person(Name, DateOfBirth);
}

Proposal

Removing boilerplate code is a key goals of records. In that spirit, I propose allowing multiple declaration parameter lists in the following manner:

public class Person
    | (string Name, DateTime DateOfBirth, string HomeTown)
    | (string Name, DateTime DateOfBirth) with { HomeTown = string.Empty };

This will produce essentially the v2 class above. (Note, I believe there are inconsistencies in the above quoted example as compared with the rest of the records proposal. This proposal should be taken as to reflect the final implementation of records.)

Here is another example which extends beyond backwards compatibility and provides different parameter lists altogether:

public class Date
    | (int Year, int Month, int Day) with { DateTime = new DateTime(Year, Month, Day) }
    | (DateTime DateTime) with { Year = DateTime.Year, Month = DateTime.Month, Day = DateTime.Day };

In this case it produces four properties (Year, Month, Day, and DateTime) and appropriate boilerplate methods.

The pipe character | is used to separate parameter lists. The first | is optional (similar to F# pattern matching syntax).

The with clause builds from the same syntax structure as in the current proposal. In this case, it is used to specify values for properties defined only in other parameter lists. (default will be assumed when a property is not specified in the parameter list and is not set via with clause.)

It is considered an error to specify two parameters in separate parameter lists that have the same name but different types.

[bondsbw]

I considered using a comma , as the separator. It starts visually running together if the lists are not specified on separate lines:

public class Person (string Name, string HomeTown), (string Name);

// versus

public class Person (string Name, string HomeTown) | (string Name);

I would appreciate thoughts on that or alternative ideas.

[gafter]

This proposal adds language support for something that is likely to be rare. I'd rather see the need for it occurring widely in practice (which I doubt will occur) before considering adding it to the language.