Sort

We call sort() to order elements in F#. For more advanced sorts, we can provide a function to sortBy—this selects a key that is then sorted.

For sorting, we must decide whether we can use a built-in sort (like an alphabetical sort over strings) or whether a lambda-based sort is needed.

First example

Here we introduce a string list containing the names of geometric shapes. We call List.sort with this list as the argument.

let shapes = ["triangle"; "square"; "ellipse"; "rectangle"]

// Use List.sort to sort the string list.
// ... A sorted copy is returned.
let result = List.sort shapes

// Print both lists.
printfn "Unsorted: %A" shapes
printfn "  Sorted: %A" result
Unsorted: ["triangle"; "square"; "ellipse"; "rectangle"]
  Sorted: ["ellipse"; "rectangle"; "square"; "triangle"]

List.sortBy

This function is more advanced. It lets us select a key to sort for each element. The lambda we pass to sortBy must return a value—this is sorted.

let values = ["aa"; "x"; "zzz"; "yy"; "eeee"]

// Sort the string list by length in ascending (low to high) order.
let result = List.sortBy (fun (x : string) -> x.Length) values

// Print our results.
List.iter(fun x -> printfn "%A" x) result
"x"
"aa"
"yy"
"zzz"
"eeee"

Array.sort, sortInPlace

An array in F# is not the same as a list—an array is a low-level region of memory with elements. We must use special Array functions to sort.

let offsets = [|10; 2; -2; 4; 40|]
let copy = Array.sort offsets

printfn "Array = %A" offsets
printfn "Copy = %A" copy

Array.sortInPlace offsets
printfn "After sortInPlace = %A" offsets
Array = [|10; 2; -2; 4; 40|]
Copy = [|-2; 2; 4; 10; 40|]
After sortInPlace = [|-2; 2; 4; 10; 40|]

Seq.sort, pipeline

We can sort collections with Seq.sort. With Seq.ofList, we treat a list as a sequence. Then we can use functions like where and sort in a pipeline.

let animals = ["cat"; "bird"; "zebra"; "leopard"; "shark"]

// Act on list as a sequence.
// ... Use where to filter our list.
//     Use Seq.sort to sort the sequence.
//     Use Seq.toList to convert back to a list.
let sortResult =
    Seq.ofList animals
    |> Seq.where (fun x-> x.Contains "a")
    |> Seq.sort
    |> Seq.toList

// Print all our results.
List.iter (fun (x : string) -> printfn "%A" x) sortResult
"cat"
"leopard"
"shark"
"zebra"

With this language, we have features that are well-suited to advanced sorting. We have lambdas and immutable collections (like lists). We invoke built-in sort methods.