[Proposal] Extend with expression to anonymous type

[leandromoh]

Extend with expression to anonymous type

• Proposed
• Prototype: Done.
• Implementation: Done,
• Specification: Not Started

Speclet: https://github.com/dotnet/csharplang/blob/main/proposals/csharp-10.0/record-structs.md

Summary

The with expression, introduced in C# 9, is designed to produce a copy of the receiver expression, in a "non-destructive mutation" manner.

This proposal extend with expression to anonymous type, since they are also immutable, the feature may fit well with them too.

Note: F# has a very similar feature called copy and update record expressions.

Motivation

Reduce boilerplate code to create new instances of anonymous type based on already existing instance.

Current approach:

var person = new { FirstName = "Scott", LastName = "Hunter", Age = 25 };

var otherPerson = new { person.FirstName, LastName = "Hanselman", person.Age };

Proposed:

var person = new { FirstName = "Scott", LastName = "Hunter", Age = 25 };

var otherPerson = person with { LastName = "Hanselman" };

Detailed design

The syntax is the same described in with expression section of the record proposal, that is

with_expression
    : switch_expression
    | switch_expression 'with' '{' member_initializer_list? '}'
    ;

member_initializer_list
    : member_initializer (',' member_initializer)*
    ;

member_initializer
    : identifier '=' expression
    ;

In the context of this proposal, the receiver expression must be an anonymous object. Also, different of the original with proposal, the anonymous type will not need contains an accessible "clone" method, since the copy can be done by the compiler just calling the constructor of the anonymous type, what maintain how anonymous types are emitted.

Currently, each anonymous type's property has a correspondent parameter in the type constructor, with same name and type. So compiler must pass the correspondent member expression for each argument. Case the member exists in the member_initializer_list, compiler must pass as equivalent argument the expression on the right side of the member_initializer.

The orders each member_initializer appears is irrelevant, since they will be processed in constructor call, therefore in the order of the parameters.

Drawbacks

None.

Alternatives

One workaround is use reflection and expression trees to build such anonymous type's constructor call. However theses features have performance cost and are, perhaps, not common for all programmers of the language. It also requires new intermediary anonymous instances to represent the properties and values that we will be changed. Here is a gist with my workaround with follow usage:

var otherPerson = person.With(new { LastName = "Hanselman" });

Unresolved questions

Design meetings

• https://github.com/dotnet/csharplang/blob/main/meetings/2020/LDM-2020-06-22.md#with-expressions-on-non-records (approved this scenario)

[leandromoh]

In case of someone is looking for such feature, here is a gist with my workaround. with follow usage:

var otherPerson = person.With(new { LastName = "Hanselman" });

[333fred]

I'm willing to champion this extension, with the caveat that it won't come in 9 :)

[HaloFour]

Makes sense, you could probably consider anonymous types to automatically be records given they already have value equality, no?

[333fred]

Possibly. It would still depend on whether we add anything else to the definition of a record type. I'm not sure whether we'd add a copy constructor, for example, or if we'd just do the copy at call site.

[333fred]

@leandromoh this will need an actual spec. Would you be willing to take a stab at writing one? It would need to be an extension to the existing records proposal.

[HaloFour]

Would "withers" come for free if an anonymous type definition was modified so that:

1. Every property was { get; init; } instead of { get; }, and
2. The anonymous type exposed a Clone method which would create a shallow clone of the anonymous type?

[333fred]

Probably, but then every piece of code generates an anonymous type would need to be recompiled to work with this feature.

[svick]

@333fred Since anonymous types can't be exposed publicly, why would that be a problem?

[333fred]

I suppose it might be fine. Still, we need a spec to actually evaluate this :)

[leandromoh]

@leandromoh this will need an actual spec. Would you be willing to take a stab at writing one? It would need to be an extension to the existing records proposal.

@333fred I would like to do it, of course. I just need to know exactly what and how to do it.
if someone explain me, I will be glad to contribute more.

[333fred]

Basically, look at the existing records proposal (https://github.com/dotnet/csharplang/blob/master/proposals/records.md#with-expression) and detail exactly how it would need to be modified in order to support withing an anonymous type. How would it actually function? Would we make changes to how anonymous types are emitted as @HaloFour suggested to generate a copy constructor & mark the properties as init, or would we do codegen at the with invocation site? I think the former approach has promise, but it needs to be investigated and formalized. The proposal template is here: https://github.com/dotnet/csharplang/blob/master/proposals/proposal-template.md. Note: don't make a PR yet, just filling it out in this issue is fine for now.