[RFC FS-1024 Discussion] Simplify Call Syntax for Statically Resolved Member Constraints

[neoeinstein]

This is the discussion thread for RFC FS-1024.

[21c-HK]

With regards to the unresolved questions in the RFC:

Should we allow the similarly simplified syntax for static members?

Definitely. Not just for consistency reasons, but because it is equally useful with regards to static members.

should it be ^T.Inc i instead

Yes, because ^T makes it apparent that T is a statically resolved type parameter and not a proper type called T. I would find it confusing otherwise. This also prevents the shadowing issue that would break backwards compatibility.

Also: Is there a simplified syntax suggestion for the or keyword instead of explicit static member constraints?

[RealmPlume]

I would rather it looks like this:

type Example() =
    member __.F(i) = printfn "%d" i

let inline f (x : ^a) =
     do x?.F 1
     do x?.F 2

it's neat.

[vasily-kirichenko]

@greatim don't confuse familiarity with good design. You are just used to use ?. in C#/Kotlin/Nemerle.

[RealmPlume]

@vasily-kirichenko

Just like , it can be another symbol:

x^.F 1
x@.F 1

whatever

[rmunn]

I'd like to see fsharp/fslang-suggestions#641 considered for inclusion in this RFC as well.

[voronoipotato]

@greatim What value is there for having a different operator there. It seems like it is not idiomatic F#, given that operator overloading is the norm. Unless you have a good argument that it's actually an entirely different operator there.

[Happypig375]

Are there reasons for not allowing

let inline inferredMemberConstraint x = x.Foo

and

let inline inferredStaticMemberConstraint (x:^T) = ^T.Foo

?
This is in line with the compiler inferring as much information as possible.

[pr-yemibedu]

Hello,
Maybe we can get rid of the ^type when or when ^type (depending on how you are reading it) part of the prefix to the constraint:

f (x : ^a when ^a : (member F : int -> unit))

inc < ^T when ^T : (static member Inc : int -> int)>

as this should be expected after the colon especially with the static specifier:

f (x : ^a : (member F : int -> unit))

inc<^T : (static member Inc : int -> int)>

that can lead to clean lines like:

let make<'T : (new : unit -> 'T)> () = new 'T()
let inline mr<^T, ^U : (map : ^T -> ^U), ^U, ^V : (reduce: ^U -> ^V)> xs = xs |> map |> reduce

and is in line with the notion to simplify the notation. It can de-sugar to include the when ^type or and ^type as needed

This could be a stepping stone to getting to the version @Happypig375 has shown above. Thank you. Good day.

[Demuirgos]

what's the status of this feature ?

[cartermp]

Not implemented.