Question

I have a piece of code:

links
    |> Seq.map (fun x -> x.GetAttributeValue ("href", "no url"))

Which I wanted to rewrite to:

links
    |> Seq.map (fun x -> (x.GetAttributeValue "href" "no url"))

But the F# compiler doesn’t seem to like that. I was under the impression that these two function calls were interchangeable:

f (a, b)
(f a b)

The error that I get is:

The member or object constructor ‘GetAttributeValue’ taking 2 arguments are not accessible from this code location. All accessible versions of method ‘GetAttributeValue’ take 2 arguments.

Which seems amusing, as it seems to indicate that it needs what I’m giving it. What am I missing here?

Answer 1

A usual function call in F# is written without parentheses and parameters are separated by spaces. The simple way to define a function of several parameters is to write this:

let add a b = a + b

As Pascal noted, this way of specifying parameters is called currying – the idea is that a function takes just a single parameter and the result is a function that takes the second parameter and returns the actual result (or another function). When calling a simple function like this one, you would write add 10 5 and the compiler (in principle) interprets this as ((add 10) 5). This has some nice advantages – for example it allows you to use partial function application where you specify only a first few arguments of a function:

let addTen = add 10 // declares function that adds 10 to any argument
addTen 5  // returns 15
addTen 9  // returns 19

This feature is practically useful for example when processing lists:

// The code using explicit lambda functions..
[ 1 .. 10 ] |> List.map (fun x -> add 10 x) 

// Can be rewritten using partial function application:
[ 1 .. 10 ] |> List.map (add 10) 

Now, let’s get to the confusing part – in F#, you can also work with tuples, which are simple data types that allow you to group multiple values into a single values (note that tuples aren’t related to functions in any way). You can for example write:

let tup = (10, "ten")    // creating a tuple
let (n, s) = tup         // extracting elements of a tuple using pattern 
printfn "n=%d s=%s" n s  // prints "n=10 s=ten"

When you write a function that takes parameters in parentheses separated by a comma, you’re actually writing a function that takes a single parameter which is a tuple:

// The following function:
let add (a, b) = a * b

// ...means exactly the same thing as:
let add tup = 
  let (a, b) = tup  // extract elements of a tuple
  a * b

// You can call the function by creating tuple inline:
add (10, 5)
// .. or by creating tuple in advance
let t = (10, 5)
add t

This is a function of a different type – it takes a single parameter which is a tuple, while the first version was a function that took two parameters (using currying).

In F#, the situation is a bit more complicated than that – .NET methods appear as methods that take a tuple as a parameter (so you can call them with the parenthesized notation), but they are somewhat limited (e.g. you cannot create a tuple first and then call the method giving it just the tuple). Also, the compiled F# code doesn’t actually produce methods in the curried form (so you cannot use partial function application directly from C#). This is due to performance reasons – most of the times, you specify all arguments and this can be implemented more efficiently.

However, the principle is that a function either takes multiple parameters or takes a tuple as a parameter.