Tuple vs * star types in F#

Question

Consider the following code:

let pair = System.Tuple.Create (10, "foo")       // val pair : int * string = (10, "foo")
let tuple = System.Tuple.Create <| (10, "foo")   // val tuple : System.Tuple<int * string> = ((10, "foo"))

1. Why doesn't the two lines yield values of the same type? Does the type of the argument (10, "foo") somehow change between the two lines?
2. What's the exact difference between int * string and System.Tuple<int * string>?

For 2, at least the latter has null as a value (this is how this question came up). Are there other differences?

Answer 1

There are two different overloads of Tuple.Create:

 Tuple.Create<'T1>(item1: 'T1)
 Tuple.Create<'T1, 'T2>(item1: 'T1, item2: 'T2)
 

In the first case you just calling a method with two arguments. So the second Tuple.Create overload is obviously picked. No surprise.

But with piping you first create a tuple instance. And then pass it to Tuple.Create method. This is what happens in the second example

  let intermediate : Tuple<int, string> = (10, "foo")
  let tuple = Tuple.Create(intermediate)

With a single argument the first Tuple.Create overload will be picked.

Note: star type is a way tuple type names are written in F#. So Tuple<int, string, bool> will be (int * string * bool). It's the same thing.