imply record labels from expressions

[dsyme]

I propose we allow both records and anonymous records to imply record labels from a limited range of expressions, e.g. for anonymous records:

{| x.Name; x.Title |}

is the same as

{| Name=x.Name; Title=x.Title |}

The same would apply for records. The label names would be implied by a expr.Name lookup only.

It would be natural to do this at the same time as anonymous records.

The existing way of approaching this problem in F# is to write the label names explicitly.

Pros and Cons

The advantages of making this adjustment to F# are succinctness

The disadvantages of making this adjustment to F# are you have to know the rule, and it makes the selection of type a little more implicit, especially in the case of records.

Extra information

Estimated cost (XS, S, M, L, XL, XXL): M

Related suggestions: #207

[gusty]

Would it be the same way as it is in C#?

[0x53A]

When implementing this, please make Refactor-Rename smart enough to add the label.

Example:

type R = { X : int }

let p = Point(1,2) // with properties X / Y
let r : R = { p.X }

if I now rename R.X to R.Z, then it should change the last line to let r : R = { Z = p.X }. Vice versa if you rename p.X.

[jwosty]

Personally, I'm not a fan of this. A rule like this doesn't seem very novice-friendly and is not immediately intuitive to me. Just my two cents though.

[baronfel]

As a counterpoint, javascript/typescript these days makes it very common to (de)construct values in this way. It's common to build objects like

let thing = { foo, bar, baz }

and get an object with "foo", "bar", "baz" keys whose values are the values bound to those names at that point.

Consequently, deconstructing is very nice in this simple case, while still allowing for the current more customizable syntax.

In short, I <3 this suggestion.

[TIHan]

I'm not sure how I feel about this feature. I personally prefer to be explicit with the fields. Also, @0x53A raises a very good point; Refactor-Rename would need to be aware of this.

I understand the intention is to be succinct, but we can agree that isn't always a good thing. My fear is that devs will be more inclined to name their properties or fields a certain way, even if it's not correct, so that they will be able to construct records in this succinct manner.

[Rickasaurus]

This seems kinda confusing to me without much gain. To a beginner it might look an awful lot like you're making an array given the syntactic similarities, when it's very different.

[Alxandr]

I'd say this is common enough in other languages (both C# and JS has similar features).

[jwosty]

What should happen if you write this?

{ foo=x.Name; x.Title }