sort -bytestring -package

sort :: Ord a => [a] -> [a]
base Data.List
The sort function implements a stable sorting algorithm. It is a special case of sortBy, which allows the programmer to supply their own comparison function.
sort :: Ord a => Seq a -> Seq a
containers Data.Sequence
O(n log n). sort sorts the specified Seq by the natural ordering of its elements. The sort is stable. If stability is not required, unstableSort can be considerably faster, and in particular uses less memory.
sortBy :: (a -> a -> Ordering) -> [a] -> [a]
base Data.List
The sortBy function is the non-overloaded version of sort.
sortBy :: (a -> a -> Ordering) -> Seq a -> Seq a
containers Data.Sequence
O(n log n). sortBy sorts the specified Seq according to the specified comparator. The sort is stable. If stability is not required, unstableSortBy can be considerably faster, and in particular uses less memory.
sortWith :: Ord b => (a -> b) -> [a] -> [a]
base GHC.Exts
The sortWith function sorts a list of elements using the user supplied function to project something out of each element
heapsort :: Ord a => [a] -> [a]
fgl Data.Graph.Inductive.Internal.Heap
topSort :: Graph -> [Vertex]
containers Data.Graph
A topological sort of the graph. The order is partially specified by the condition that a vertex i precedes j whenever j is reachable from i but not vice versa.
topsort :: Graph gr => gr a b -> [Node]
fgl Data.Graph.Inductive.Query.DFS
topsort' :: Graph gr => gr a b -> [a]
fgl Data.Graph.Inductive.Query.DFS
unstableSort :: Ord a => Seq a -> Seq a
containers Data.Sequence
O(n log n). unstableSort sorts the specified Seq by the natural ordering of its elements, but the sort is not stable. This algorithm is frequently faster and uses less memory than sort, and performs extremely well -- frequently twice as fast as sort -- when the sequence is already nearly sorted.
unstableSortBy :: (a -> a -> Ordering) -> Seq a -> Seq a
containers Data.Sequence
O(n log n). A generalization of unstableSort, unstableSortBy takes an arbitrary comparator and sorts the specified sequence. The sort is not stable. This algorithm is frequently faster and uses less memory than sortBy, and performs extremely well -- frequently twice as fast as sortBy -- when the sequence is already nearly sorted.