Function signature is different when it's part of a type (it's not generic anymore)

Question

Why do the signatures of these functions differ?

This function:

type a () = 
    member this.ThirdElementOfTupleFromListToSequence = function 
        | (q, w, ids) -> (q,w, (List.toSeq ids))

has this signature: (obj * obj * obj list -> obj * obj * seq<obj>)

and when I assign the same function using let:

let ThirdElementOfTupleFromListToSequence = function 
    | (q, w, ids) -> (q,w, (List.toSeq ids))

it has this signature: ('a* 'b * 'c list -> 'a * 'b * seq<'c>)

both function aren't used anywhere.

Answer 1

The problem here is that you are not defining a method, but a property whose value happens to be a function. And in .NET, properties cannot be generic.

In order to make it a method, you need to make it explicit in the declaration:

type a () =
    member this.ThirdElementOfTupleFromListToSequence(q, w, ids) =
        (q,w, (List.toSeq ids))

Or to make it more similar to your original version

type a () =
    member this.ThirdElementOfTupleFromListToSequence(arg) =
        match arg with
        | (q, w, ids) -> (q,w, (List.toSeq ids))

(Note that these two versions are actually different -- the first one is a method with three arguments, and the second one is a method with one argument which is a tuple).

Answer 2

The reason the type signatures are different is because the CLR does not support generic properties; see: Why does C# not allow generic properties?

In your first example, the compiler infers the generic parameters just as it does for the let-bound example, but it has to "fill in" the generic parameters since it isn't allowed to create a generic property. The compiler uses obj in place of the generic parameters because that's guaranteed to work.