F# lets you define your own operators, and like a man with a new hammer hunting for nails :) I’ve found an application of F# custom operators for sorting multiple columns:
let inline (|?) a b = if a = 0 then b else a
Lets start by trying to sort the table position of the current top 5 of English Football’s Premier League (compiled on 2010-01-21):
Team |
Played |
Goal Difference |
Points |
Arsenal |
22 |
34 |
48 |
Chelsea |
21 |
34 |
48 |
Man Utd |
22 |
30 |
47 |
Spurs |
22 |
18 |
38 |
Man City |
21 |
12 |
38 |
Lets say we represent the table as an array of tuples:
let table = [|
("Arsenal", 22, 34, 48)
("Chelsea", 21, 34, 48)
("Spurs", 22, 18, 38)
("Man City",21, 12, 38)
("Man Utd", 22, 30, 47)
|]
If we could just sort on points, and wanted to sort the array in place, we could write:
do Array.Sort(table, fun (_,_,_,a) (_,_,_,b) -> b - a)
But as we can see from the table, some of the teams have the same points, so we need to order on points and goal difference. In the case of Arsenal and Chelsea at the top of the table, they not only have the same points, they have the same goal difference. In this situation the custom is to sort alphabetically (lucky for you if your team starts with the letter ‘A’).
The sort function must now apply secondary sorting criteria if the first expression gives zero:
do Array.Sort(table, fun a b ->
let nameA, _, gdA, pointsA = a
let nameB, _, gdB, pointsB = b
let points = pointsB - pointsA
let gd = gdB - gdA
let names = String.Compare(nameA, nameB)
if points <> 0 then points
else if gd <> 0 then gd
else names
)
)
Now the custom operator introduced at the start of the article really captures it:
do Array.Sort(table, fun a b ->
let nameA, _, gdA, pointsA = a
let nameB, _, gdB, pointsB = b
pointsB - pointsA |? gdB - gdA |? String.Compare(nameA, nameB)
)
The beauty of using the custom operator here, say over a function, is operators can be placed between expressions so can be used to compose the sort.
Finally, there are however a couple of other ways to hammer this nail:
- sort by mapping the table entry tuple
- using LINQ OrderBy and ThenBy
Mapping the table entry is easy on the eye but it does require the generation of temporary tuples and a new array:
do table |> Array.sortBy (fun (name,_,gd,points) -> -points,-gd,name)
Using LINQ is also pretty easy on the eye but requires the generation of a new sequence:
do table.OrderByDescending(fun (_,_,_,p) -> p)
.ThenByDescending(fun (_,_,gd,_) -> gd)
.ThenBy(fun (name,_,_,_) -> name)
PS If you are looking for a similar pattern in C#, Jon Skeet shows a similar (but more verbose) way of composing sort expressions using the ?? operator in his C# in Depth book.
PPS Tomas Petricek has a nice article with some sample use of custom operators in F#. Coincidentally he has just authored a book with Mr Skeet on Functional Programming.
PPPS For clarity I should point out that I am a Man Utd supporter, so the timing for this article could be seen as somewhat unfortunate.