What is the difference between these functions
currying, f#, function
Solution
Your assumption is correct, in this case, the functions are exactly the same.
You can see that by inspecting the generated IL code (as demonstrated by Craig) and you can also see that by looking at the type inferred by the F# compiler. In both cases, you'll see `int -> int -> int`. The F# language views that as a function that takes `int` and returns `int -> int` but it is actually compiled as a method with multiple arguments (for efficiency).
If you write `fun` immediately following `let .. =` then the compiler turns that into a standard function. However, you can write code that is a bit different if you do some computation before returning the function:
let f1 a b = printfn "hi"; a + b
let f2 a = printfn "hi"; (fun b -> a + b)
Now the two functions are very different, because the second one prints "hi" when you give it just a single argument (and then it returns a function that you can call):
> let f = f2 1;;
hi // The body is called, prints
val f : (int -> int) // and returns function
> f 2;; // This runs the body of 'fun'
val it : int = 3 // which performs the additiion
You can write the same code using `f1`, but the first command will just create a new function and the second command will print "hi" and do the addition.
In this case, the generated IL code for `f2` will be different. It will be a function that returns a function (of type `FSharpFunc<int, int>`). The type displayed by F# is also different - it will be `int -> (int -> int)` instead of `int -> int -> int`. You can use values of these two types in exactly the same ways, but it hints you that the first one may do some effects when you give it a single argument.
Problem
Are these functions exactly same? That is, are 1st and 2nd syntax just convenient shorthand for the last syntax? Or is there some theoretical or practical difference, and if so, what is it? `let f1 a b = a + b` `let f2 a = (fun b -> a + b)` `let f3 = (fun a -> (fun b -> a + b) )` They seem the same to me, `f1 5`, `f2 5` and `f3 5` seem to return identical value, for instance. Just checking I'm not making invalid assumption here. In other words, I hope a knowledge-based answer, not one saying "Yeah, I believe they are the same".