:: Ord a => [a] -> [a] is:exact -package:containers -package:Cabal -package:extra -package:lens

Remove duplicates but keep elements in order. O(n * log n)

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. The argument must be finite.

Examples

>>> sort [1,6,4,3,2,5]
[1,2,3,4,5,6]

>>> sort "haskell"
"aehklls"

>>> import Data.Semigroup(Arg(..))

>>> sort [Arg ":)" 0, Arg ":D" 0, Arg ":)" 1, Arg ":3" 0, Arg ":D" 1]
[Arg ":)" 0,Arg ":)" 1,Arg ":3" 0,Arg ":D" 0,Arg ":D" 1]

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]

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.

Examples

>>> cycle []
*** Exception: Prelude.cycle: empty list

>>> take 10 (cycle [42])
[42,42,42,42,42,42,42,42,42,42]

>>> take 10 (cycle [2, 5, 7])
[2,5,7,2,5,7,2,5,7,2]

>>> take 1 (cycle (42 : undefined))
[42]

Return all the elements of a list except the last one. The list must be non-empty. WARNING: This function is partial. Consider using unsnoc instead.

Examples

>>> init [1, 2, 3]
[1,2]

>>> init [1]
[]

>>> init []
*** Exception: Prelude.init: empty list

reverse xs returns the elements of xs in reverse order. xs must be finite.

Laziness

reverse is lazy in its elements.

>>> head (reverse [undefined, 1])
1

>>> reverse (1 : 2 : undefined)
*** Exception: Prelude.undefined

Examples

>>> 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.

Warning: This is a partial function, it throws an error on empty lists. Replace it with drop 1, or use pattern matching or Data.List.uncons instead. Consider refactoring to use Data.List.NonEmpty.

tailSafe [] = []
tailSafe [1,3,4] = [3,4]

Extract the elements after the head of a list, which must be non-empty.

Examples

>>> tail [1, 2, 3]
[2,3]

>>> tail [1]
[]

>>> tail []
*** Exception: Prelude.tail: empty list

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]

Sort a vector.

The nub function which removes duplicate elements from a vector.

Sort 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

Generalized version of runInBoundThread.

Generalized version of runInUnboundThread.