Allow change generic types in with expressions

[lucasteles]

When working with large generic data structures and we need to copy all data but change some generic type field to another type we can't use with and have to explicitly copy each field of the record. eg:

type Foo<'t> = {
  A: int
  B: 't
  C: string
}

let fooInt = { A = 1; B = 2; C = "foo" }

// do not compile 
let fooString = { fooInt with B = "three" } 

I believe this makes sense, just changing the type would look dangerous. But I think we could have some way to do this when wanted:

let fooString = { fooInt with B<string> = "three" } 

// or also 
let fooString = { fooInt with B<_> = "three" } 

The existing way of approaching this problem in F# is

Explicitly set each field without with

let fooString = { A = fooInt.A; B = "three"; C = fooInt.C }

Pros and Cons

The advantages of making this adjustment to F# are
easier data structure manipulation

The disadvantages of making this adjustment to F# are
add complexity to the syntax

Extra information

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

Related suggestions:

Affidavit (please submit!)

Please tick this by placing a cross in the box:

• This is not a question (e.g. like one you might ask on stackoverflow) and I have searched stackoverflow for discussions of this issue
• I have searched both open and closed suggestions on this site and believe this is not a duplicate
• This is not something that has obviously "already been decided" in previous versions of F#. If you're questioning a fundamental design decision that has obviously already been taken (e.g. "Make F# untyped") then please don't submit it.

Please tick all that apply:

• This is not a breaking change to the F# language design
• I or my company would be willing to help implement and/or test this

For Readers

If you would like to see this issue implemented, please click the 👍 emoji on this issue. These counts are used to generally order the suggestions by engagement.

[smoothdeveloper]

Another workaround:

type Foo<'t> = 
  {
    A: int
    B: 't
    C: string
  }
  static member mapB f x = { A = x.A; B = f x.B; C = x.C }

let fooInt = { A = 1; B = 2; C = "foo" }
let fooString = Foo.mapB (fun _ -> "three") fooInt 

I agree it would feel natural, but I'm concerned about people inadvertently changing the type, and I'm not convinced with the generic parameter adorned to the field name.

let fooString : Foo<string> = { fooInt with B = "three" } 
let fooString : Foo<_> = { fooInt with B = "three" } 

Maybe this would be better, without changing the grammar?

[realparadyne]

This feels very related to the already approved-in-principle spread operator. #1253

You want to take what you can from the existing record but provide a new value for one (or more) of the fields and if those are of a different type, then the newly produced record is of a suitable type (anonymous or not).

It just sounds like a specific case that the spread operator will be needing to support and may already be intended.

[lucasteles]

Closing in favor of #1253