add FS-1331 - Allow opens in type and expression scopes

[ijklam]

Click “Files changed” → “⋯” → “View file” for the rendered RFC.

[Martin521]

Shouldn't this be considered an expressions-scoped open and NOT be valid in the member?

[ijklam]

The original suggestion doesn't mentioned this, but I think the contents opened in type should be valid in members.

[Martin521]

Yes, that makes sense. I was somehow thinking of an open inside the do body. Good that you added the extra example above for it.

[T-Gro]

Are there any foreseen deviations from a module level open ? I assume those can arise from the implementation.
If yes, I would like to have them listed here (inconsistency being the drawback).

[edgarfgp]

In Lambdas ?

[ 1..10 ]
|> List.iter (fun x ->
    open System
    Console.WriteLine($"Value: {x}"))

[ijklam]

Lambda is ok

[edgarfgp]

Can we please add some samples about ?

type IFace =
    abstract F : int -> int
    open System
    member _.F _ = 3
        
{ new IFace with
    open System
    member _.F _ = 3
}

type C () =
    member _.F () = 3
    open System
    member _.F _ = 3
    open System
    interface IFace with
        open System
        member _.F _ = 3
       
type A =
    | A
    open System
    member _.F _ = 3
and B =
    | B
    open System
    member _.F _ = 3

type U =
    | A
    | B
    open System
    member _.F _ = 3

type R =
    open System
    { A : int }
    open System
    member _.F _ = 3

[ijklam]

opens in types can only be on the beginning of the type definition due to the complexity of making it can applied to member/val/interface ... with following the up-to-down order.
Object expressions and interface ... with cannot contain opens.

[smoothdeveloper]

I'd be fine with the feature shipping, with none of the places @edgarfgp showcased, being supported; and giving more room for consideration about the samples and in-type-definition semantics.

Ideally, it could be used in a do block at type level, let bindings, and in members themselves (under the member implemention block, not in between in stuff like properties).

[Tarmil]

It looks like open type hasn't been considered. I think people will expect it to work, consistently with module-level open type, so the RFC should either include it, or explain why it doesn't.

Edit: actually it is present in the examples. Still, I think a mention in the text would be welcome.

[Martin521]

Can a section "Changes to the F# spec" be added?

[T-Gro]

That makes sense. I will re-review once spec changes are added.