Allow with operator to be used for derived records.

[jfmekker]

The with operator for use on record types is very handy. What I would like is to be able to use it to create instances of a derived record from a base record instance. See example below.

    public record Foo
    {
        public required int A { get; init; }
        public required int B { get; init; }
    }

    public record Bar : Foo
    {
        public required int C { get; init; }
    }

    public static class Test
    {
        public static void M( )
        {
            Foo f = new Foo { A = 1, B = 2 };
            Bar b = f with { C = 2 }; // does not work currently
        }
    }

This would essentially just be shorthand for:

Bar b = new Bar
{
    A = f.A,
    B = f.B,
    C = 3
};

[HaloFour]

I wonder how something like that might work. Right now with relies on the instance to clone itself, the language isn't responsible for trying to figure out which constructor to call or how to copy the properties from one instance to another.

[GabeSchaffer]

Would Bar b = new (f) with { C = 2 }; work, or is this about avoiding the creation of the temporary Bar?

[jfmekker]

Would Bar b = new (f) with { C = 2 }; work, or is this about avoiding the creation of the temporary Bar?

I think that would not work if C is required, plus you need a Bar(Foo f) constructor. If you had that constructor already, you could just do Bar b = new(f) { C = 2 };.

[HaloFour]

Could use a source generator to create a copy constructor, then the call would be:

Bar b = new(f) { C = 2 };

This would work if C is required, also.

I personally don't think with fits here as I don't think it's safe to create a different type, and there would be situations where that's not possible anyway without decapitation or loss of data:

    public record Foo
    {
        public required int A { get; init; }
        public required int B { get; init; }
    }

    public record Bar : Foo
    {
        public required int C { get; init; }
    }

    public record Baz : Foo
    {
        public required int D { get; init; }
    }

    public static class Test
    {
        public static void M( )
        {
            Foo f = new Baz { A = 1, B = 2, D = 4 };
            Bar b = f with { C = 2 }; // this definitely does not feel like it should work
        }
    }

[Klotzi111]

I like this proposal. It would reduce a lot of boilerplate code that copies all members.

Here are some additional notes:

Explicitly specify target type

The original proposal shows:

Foo f = new Foo { A = 1, B = 2 };
Bar b = f with { C = 2 }; // does not work currently

In this case this is fine but we probably also need the ability to explicitly specify target type.
Proposed syntax:

var b = f with<Bar> { C = 2 }; // does not work currently

We need such a syntax because we might have the following example situation:

• Foo implements a interface IMyRecord
• we have a method: void Use(IMyRecord r)
• we call that method with: Use(f with<Bar> { C = 2 });
  without <Bar> the new type would be deduced to Foo as it currently already does.

Restrict target types

Explicit slicing

As was already mentioned here we should not allow slicing (only copy some common properties) directly.
We should disallow this:

Baz f = new Baz { A = 1, B = 2, D = 4 };
Bar b = f with { C = 2 }; // disallow this

But copying only a subset might still be very relavant.
So we should allow it if the type (at compile-time) to be copied from is inherited by the target type:

Foo f = new Baz { A = 1, B = 2, D = 4 };
Bar b = f with { C = 2 }; // allow this since we have Foo here
// and
Baz f = new Baz { A = 1, B = 2, D = 4 };
Bar b = (f as Foo) with { C = 2 }; // allow this too

Only for inherited types

We should not allow copying properties with matching names from types that are not inherited.
Doing so would be chaos even if the types of the properties are the same.
Example:

Foo f = new Foo { A = 1 };
Bar b = f with { C = 2 }; // disallow this

public record Foo
{
    public required int A { get; init; }
}

public record Bar
{
    public required int A { get; init; }
    public required int C { get; init; }
}