Record update syntax not allowed for same type in [<Struct>] record member

[nikonthethird]

The F# compiles shows error FS3232 when attempting to construct a new struct record of the same type in a member of the record with the update syntax.

Repro steps

[<Struct>]
type R = {
    X : int32
    Y : string
} with
    member this.Shift n = { this with X = this.X <<< n }
    //                      ^^^^ Struct members cannot return the address of fields of the struct by reference

Expected behavior

The update should be allowed, since it's constructing an immutable copy.

Actual behavior

The compiler shows error FS3232: Struct members cannot return the address of fields of the struct by reference

Known workarounds

Naming all fields explicitly works:

[<Struct>]
type R = {
    X : int32
    Y : string
} with
    member this.Shift n = { X = this.X <<< n; Y = this.Y }

Related information

• Windows 10, Ubuntu 18.04
• .NET Framework 4.7.2, F# runtime 4.7.0.0
• Visual Studio 2019

[abelbraaksma]

I may be wrong, but I think I've seen in some other discussion that this is a "by design" thing, because this is implicitly a byref. Though there's something to say for the record update syntax to work with byrefs, since indeed it'll create a copy anyway (unless the record update syntax with byrefs actually updates in place? If so, the error is genuine)

[TheJayMann]

I just tried, as a workaround, you can do the following.

[<Struct>]
type R = {
  X : int32
  Y : string
} with
  member self.Shift n = let this = self in { this with  X = this.X <<< n}

I tested that it works, though I do not know how, if at all, it would affect the performance.

[cartermp]

Closing as dupe of #7536

[abelbraaksma]

I tested that it works, though I do not know how, if at all, it would affect the performance.

@TheJayMann What you're doing is making a shallow copy of the reference, and this action dereferences the inref (see linked issue for more info).

I think that one possible solution to this bug could be exactly like the code you showed.

[abelbraaksma]

Another, more idiomatic solution for the scenario of the OP is to create a static member, or a let function. The same syntax (from OP) can then be used without worrying about inref, and it simply makes more sense: after all, you're not doing any action on the type, or changing it's state, a static method is than the more obvious choice ;).