Proposal: Custom with interface

[RenderMichael]

Often times when I work with records (no pun intended), I want to use the with keyword but instead need a deep copy, leaving me to ditch with and write a custom Clone() method.

I would love to see the following new API surface

public interface IRecordCloneable<T> where T : IRecordCloneable<T>
{
    T Clone();
}

And any record implementing this interface would have IRecordCloneable<T>.Clone() invoked instead of the record-generated <Clone> method when using the with keyword.

Since there's discussion on expanding the scope of with from being record-exclusive, the name could be altered so that's not locked in (ICustomWith?).

An alternative design would be to implement the old ICloneable interface, so

public interface IRecordCloneable<T> : ICloneable where T : IRecordCloneable<T>
{
    object ICloneable.Clone() => Clone();
    new T Clone();
}

so anyone implementing ICloneable isn't affected, but you can enable with functionality by simply replacing your old Cloneable class with IRecordCloneable<self>. The latter I'm sure is more controversial, but the core concept should be considered.

[RenderMichael]

Error CS8859: Members named 'Clone' are disallowed in records. could also be special-cased to allow only IRecordCloneable<T>.Clone(). Otherwise everyone would need to implement explicitly. the record would also not need to generate the Clone() method anymore either.

[mattwar]

You should call the method DeepClone.

[RenderMichael]

I was thinking this replaces the Clone() method emitted by the record source generator. It also doesn't have to be a deep clone, that's just my most common use case.

[HaloFour]

Right now that method is "unspeakable" as it needs to follow some very specific rules otherwise the cloned type will be decapitated or something like that. I understand the team did want to revisit and make it pattern-based in which case I would assume you could provide your own implementation that would perform a deep copy.

[RenderMichael]

Ah so that's why CS8859 was introduced. If it becomes pattern-based it would suit the use cases I've encountered, but it feels weird making it implicit. anyone coming into C#12 might innocently name a method Clone() without knowing.

Maybe Clone() should require an override keyword? That might come with it's own hurdles. Whatever the resolution is, I eagerly await it.

[Joe4evr]

@RenderMichael The idea for the proper "Clone"/With method shape (at least when they last talked about it) also requires applying a new attribute, then strawman'd as [Factory] which also makes the compiler limit the return value of that method to be either new or another [Factory] method.

At least that way, any existing methods aren't expected to have pattern-based with bind to them because they will lack the attribute in question.

[ufcpp]

https://github.com/dotnet/csharplang/blob/main/meetings/2020/LDM-2020-04-20.md

The core feature requirement here is for the with expression, which needs to assign to init fields. We can head two directions: special case the Clone method, or build a more general feature. This is a spectrum, where one end may be a new syntactic form specific to just the Clone method, and the other end could be a Factory attribute that could be applied to any method.