Allow the initialization of explicit fields when using a primary constructor

[trevorgray]

I propose we allow the initialization of explicit fields when using a primary constructor.

Currently in order to initialize explicit fields, a non-primary constructor is required:

// Explicit fields assigned in constructor
type MyClass =
    val mutable a: int
    val mutable b: int
    new(a0, b0) = { a = a0; b = b0; }

// Explicit fields assigned when using primary constructor
type MyClass2() as this =
    [<DefaultValue>]
    val mutable a: int

    [<DefaultValue>]
    val mutable b: int

    do
        this.a <- 5
        this.b <- 6

// Explicit fields assigned when using let bindings
type MyClass3 private (c0: int) =
    [<DefaultValue>]
    val mutable a: int

    [<DefaultValue>]
    val mutable b: int

    let c = c0

    new(a0, b0, c0) as this =
        MyClass3(c0)
        then
            this.a <- a0
            this.b <- b0

[<Struct>]
type Struct1 =
    val mutable a: int
    new (a0) = { a = a0 }

This proposal is to update the language to allow explicit fields to be initialized when using a primary constructor so that the following is possible:

type MyClass(a0: int, b0: int) =
    val mutable a = a0
    val mutable b = b0

type MyClass2() =
    val mutable a = 5
    val mutable b = 6

type MyClass3(a0: int, b0: int, c0: int) =
    val mutable a = a0
    val mutable b = b0
    let c = c0

// Not possible today: A type that has a non-mutable explicit field and a let binding.
type MyClass4(a0: int, c0: int) =
    val a = a0
    let c = c0

// Same as today. Struct cannot have primary non-parameterless constructor so a non-primary constructor must be used.
[<Struct>]
type Struct1 =
    val mutable a: int
    new (a0) = { a = a0 }

// Not possible today: Parameterless struct constructor.
[<Struct>]
type Struct2 =
    val mutable a: int
    new () = { a = 5 }

// Alternatively using new inline initialization.
[<Struct>]
type Struct2() =
    val mutable a = 5

Related C# feature for parameterless stuct constructors:

Pros and Cons

The advantages of making this adjustment to F# are ...

• Able to have non-mutable explicit fields and let bindings in the same type
• Able to initialize explicit fields the same way as let bindings
• Less verbose way of initializing explicit fields

The disadvantages of making this adjustment to F# are ...

• More syntax

Extra information

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

Related suggestions: (put links to related suggestions here)

Affidavit (please submit!)

Please tick these items by placing a cross in the box:

• [x] This is not a question (e.g. like one you might ask on StackOverflow) and I have searched StackOverflow for discussions of this issue
• [x] This is a language change and not purely a tooling change (e.g. compiler bug, editor support, warning/error messages, new warning, non-breaking optimisation) belonging to the compiler and tooling repository
• [x] This is not something which 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
• [x] I have searched both open and closed suggestions on this site and believe this is not a duplicate

Please tick all that apply:

• [x] This is not a breaking change to the F# language design
• [x] 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 :+1: emoji on this issue. These counts are used to generally order the suggestions by engagement.

[Happypig375]

Would let mutable public be possible?

[trevorgray]

That could be an alternative to this. However, currently let bindings in types are always private and do not allow an access modifier to be applied whereas explicit fields can have any access modifier.

[bartelink]

Might be useful to reference the { inherit construct in defining the requirement