In the expression (3 * x), 3 is an integer. For an integer type the * operator is defined only to work with ints. So unless we have specified x to be of another type (in which case the compiler will throw an error) the compiler assumes the type of x to be int. The return value of int * int is int.

Now let us consider the expression x * y, where no type information has been specified for x and y. The compiler would expect the type of x and y to be something that has the operator ‘*’ defined for the type. If we haven’t overloaded the * for any custom types, the compiler would have to select from a list of types for which * is predefined. Those would be the numerical types like int, float etc.
In the absense of any additional type information to chose between them, the compiler defaults to int.

I should clarify that this is my guess, not a documented fact

You do make some interesting points.

For #1, in the context of the function that I wrote (i.e. in the absence of additional type information), x * 3 and 3 * x are both inferred as int. Why are you surprised with that? What else would you expect it to be ?

I will address your questions #2 and #3 in a separate post. You are correct in your assumptions on both.

#4 you are correct in your assertion. It would have been a good way to explain both the concepts in a way they relate to each other.

Thanks for the comments mashe.

you might want to use the form:
let addToTwo = (add 2)

which makes the subsequent expression
addToTwo 8
clearer (readers might think that the ’2′ in ‘add2′ has some significance).

1) I am surprised that the compiler infers the type of 3 * x to be int. What is the type of x * 3?

2) From the code you wrote, I think F# uses significant whitespace – you might want to explain that.

3) Functional programmers often use (tail) recursion to implement looping structures you might see in many other languages. The example you showed, I think, is not tail-recursive. Maybe something like:

let factorial num =
let rec factInternal num prod =
if (num <= 1) then
prod
else
factInternal(num-1, num*prod)
factInternal(num, 1)

is more appropriate.

4) I am going to assume that the F# syntax for defining a temporary binding is:

let somefunc arg =
let x = 1
arg +x

Couple this with the statement that functions are 'first class' and I think the nested function syntax follows naturally.

BTW, I don't know Jack about F#, so ..