F# - List.sort Examples - Dot Net Perls

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.

Result The shapes are sorted in ascending order (as strings). A copy is sorted, so the original is untouched.

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.

Result SortBy returns a copy of the List that is sorted. As with sort, the original is not changed.

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.

Array

Info Sort() returns a copied array that is sorted. It does not modify (mutate) the original array's data.

Also SortInPlace() rearranges the elements in an existing array. No new memory region is allocated.

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.

Here We use "where" to only keep elements containing a lowercase "A." Then we sort them alphabetically, and convert back to a list.

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.