Example
In F#, all functions take exactly one parameter. This seems an odd statement, since it's trivially easy to declare more than one parameter in a function declaration:
let add x y = x + y
But if you type that function declaration into the F# interactive interpreter, you'll see that its type signature is:
val add : x:int -> y:int -> int
Without the parameter names, that signature is int -> int -> int. The -> operator is right-associative, which means that this signature is equivalent to int -> (int -> int). In other words, add is a function that takes one int parameter, and returns a function that takes one int and returns int. Try it:
let addTwo = add 2
// val addTwo : (int -> int)
let five = addTwo 3
// val five : int = 5
However, you can also call a function like add in a more "conventional" manner, directly passing it two parameters, and it will work like you'd expect:
let three = add 1 2
// val three : int = 3
This applies to functions with as many parameters as you want:
let addFiveNumbers a b c d e = a + b + c + d + e
// val addFiveNumbers : a:int -> b:int -> c:int -> d:int -> e:int -> int
let addFourNumbers = addFiveNumbers 0
// val addFourNumbers : (int -> int -> int -> int -> int)
let addThreeNumbers = addFourNumbers 0
// val addThreeNumbers : (int -> int -> int -> int)
let addTwoNumbers = addThreeNumbers 0
// val addTwoNumbers : (int -> int -> int)
let six = addThreeNumbers 1 2 3 // This will calculate 0 + 0 + 1 + 2 + 3
// val six : int = 6
This method of thinking about multi-parameter functions as being functions that take one parameter and return new functions (which may in turn take one parameter and return new functions, until you reach the final function that takes the final parameter and finally returns a result) is called currying, in honor of mathematician Haskell Curry, who is famous for developing the concept. (It was invented by someone else, but Curry deservedly gets most of the credit for it.)
This concept is used throughout F#, and you'll want to be familiar with it.
