:: Ord a => [a] -> [a] -package:ghc -package:Cabal -package:basement -package:statistics -package:extra is:exact -package:generic-deriving

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. Elements are arranged from lowest to highest, keeping duplicates in the order they appeared in the input.
>>> sort [1,6,4,3,2,5]
[1,2,3,4,5,6]
The argument must be finite.
Like nub, but has O(n log n) complexity instead of O(n^2). Code for ordNub and listUnion taken from Niklas Hambüchen's ordnub package.
A right-biased version of ordNub. Example:
>>> ordNub [1,2,1] :: [Int]
[1,2]
>>> ordNubRight [1,2,1] :: [Int]
[2,1]
The nubOrd function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. By using a Set internally it has better asymptotics than the standard nub function.

Strictness

nubOrd is strict in the elements of the list.

Efficiency note

When applicable, it is almost always better to use nubInt or nubIntOn instead of this function, although it can be a little worse in certain pathological cases. For example, to nub a list of characters, use
nubIntOn fromEnum xs
Sort a vector.
The nub function which removes duplicate elements from a vector.
Removes duplicate elements from a list, keeping only the first occurrence. This is asymptotically faster than using nub from Data.List.
>>> ordNub [3,2,1,3,2,1]
[3,2,1]
A minimum that fails using mzero
A maximum that fails using mzero
cycle ties a finite list into a circular one, or equivalently, the infinite repetition of the original list. It is the identity on infinite lists.
>>> cycle []
*** Exception: Prelude.cycle: empty list

>>> cycle [42]
[42,42,42,42,42,42,42,42,42,42...

>>> cycle [2, 5, 7]
[2,5,7,2,5,7,2,5,7,2,5,7...
reverse xs returns the elements of xs in reverse order. xs must be finite.
>>> reverse []
[]

>>> reverse [42]
[42]

>>> reverse [2,5,7]
[7,5,2]

>>> reverse [1..]
* Hangs forever *
A total variant of tail.
A total variant of init.
Extract the elements after the head of a list, which must be non-empty.
>>> tail [1, 2, 3]
[2,3]

>>> tail [1]
[]

>>> tail []
*** Exception: Prelude.tail: empty list
WARNING: This function is partial. You can use case-matching or uncons instead.
Return all the elements of a list except the last one. The list must be non-empty.
>>> init [1, 2, 3]
[1,2]

>>> init [1]
[]

>>> init []
*** Exception: Prelude.init: empty list
WARNING: This function is partial. You can use reverse with case-matching or uncons instead.
tailSafe [] = []
tailSafe [1,3,4] = [3,4]
Identical to tail, namely that fails on an empty list. Useful to avoid the x-partial warning introduced in GHC 9.8.
tailErr [] = error "Prelude.tail: empty list"
tailErr [1,2,3] = [2,3]
Generalized version of runInBoundThread.
Generalized version of runInUnboundThread.
Generalized version of mask_.
Generalized version of uninterruptibleMask_.
List of elements of a structure, from left to right. If the entire list is intended to be reduced via a fold, just fold the structure directly bypassing the list.

Examples

Basic usage:
>>> toList Nothing
[]
>>> toList (Just 42)
[42]
>>> toList (Left "foo")
[]
>>> toList (Node (Leaf 5) 17 (Node Empty 12 (Leaf 8)))
[5,17,12,8]
For lists, toList is the identity:
>>> toList [1, 2, 3]
[1,2,3]
all nodes of a tree