Question

The function matching is based on the definition of the file in F#:

let f2 x y = x + y
let value5 = f2 10 20
let value = f2(10, 20) <-- Error

let f3 (x, y) = x + y
let value6 = f3(10, 20)
let value = f3 10 20 <-- Error

However, I can use in both ways with one parameter with F#:

let f n = n + 10
let value3 = f 10
let value4 = f(10)

Why is this? Does F# treat parameter matching differently when there is only one input parameter?

Answer 1

As ashays correctly explains, the two ways of declaring functions are different. You can see that by looking at the type signature. Here is an F# interactive session:

> let f1 (x, y) = x + y;;  
val f1 : int * int -> int

> let f2 x y = x + y;;
val f2 : int -> int -> int

The first function takes a tuple of type int * int and returns int. When calling it, you need to specify the tuple (which is just a single value):

// Using tuple directly as the argument
f1 (1, 2)

// .. or by declaring tuple value first
let tup = (1, 2)
f1 tup

The type of the second function is int -> int -> int, which is the same thing as int -> (int -> int). This means that it is a function that takes int and returns a function that takes int and returns int. This form is called curried form and it allows you to use partial function application as demonstrated by ashays. In fact, the call:

f2 1 2

// Could be written as:
(f2 1) 2