The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means `essence'.) It is a special case of nubBy, which allows the programmer to supply their own equality test.

>>> nub [1,2,3,4,3,2,1,2,4,3,5]
[1,2,3,4,5]

If the order of outputs does not matter and there exists instance Ord a, it's faster to use map Data.List.NonEmpty.head . Data.List.NonEmpty.group . sort, which takes only <math> time.

The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means 'essence'.) It is a special case of nubBy, which allows the programmer to supply their own inequality test.

O(n log n). Fold values into a list with duplicates removed, while preserving their first occurrences

The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means `essence'.) It is a special case of nubBy, which allows the programmer to supply their own equality test.

>>> nub [1,2,3,4,3,2,1,2,4,3,5]
[1,2,3,4,5]

The nub function which removes duplicate elements from a vector.

Return a new Shell that discards duplicates from the input Shell:

>>> view (nub (select [1, 1, 2, 3, 3, 4, 3]))
1
2
3
4

Removes duplicate elements from the list. See also nubBy

On ordered lists, nub is equivalent to nub, except that it runs in linear time instead of quadratic. On unordered lists it also removes elements that are smaller than any preceding element.

nub [1,1,1,2,2] == [1,2]
nub [2,0,1,3,3] == [2,3]
nub = nubBy (<)

O(n log n). Remove duplicate entries from the heap.

>>> nub (fromList [1,1,2,6,6])
fromList [1,2,6]

O(n). Remove duplicate elements from a sorted list.

Used as a scan. Returns Just for the first occurrence of an element, returns Nothing for any other occurrences. Example:

>>> stream = Stream.fromList [1::Int,1,2,3,4,4,5,1,5,7]

>>> Stream.fold Fold.toList $ Stream.scanMaybe Fold.nub stream
[1,2,3,4,5,7]

Pre-release

The memory used is proportional to the number of unique elements in the stream. If we want to limit the memory we can just use "take" to limit the uniq elements in the stream.

Delete all but the first copy of each element, special case of nubBy.

O(n). This upgrades nub from Data.List from O(n^2) to O(n) by using productive unordered discrimination.

nub = nubWith id
nub as = head <$> group as

Remove duplicate from a list, keeping only the first occurrence of each element.

Version of the traditional nub function using the PartialOrd notion of equality.

Remove all duplicates. Since 0.7.0.0

O(n^2). Removes duplicate elements from a slist. In particular, it keeps only the first occurrence of each element. It is a special case of nubBy, which allows to supply your own equality test.

>>> nub $ replicate 5 'a'
Slist {sList = "a", sSize = Size 1}

>>> nub mempty
Slist {sList = [], sSize = Size 0}

>>> nub $ slist [1,2,3,4,3,2,1,2,4,3,5]
Slist {sList = [1,2,3,4,5], sSize = Size 5}

Functions to remove duplicates from a list.

Performance

To check the performance there was done a bunch of benchmarks. Benchmarks were made on lists of Ints and Texts. There were two types of list to use:

• Lists which consist of many different elements
• Lists which consist of many same elements

Here are some recommendations for usage of particular functions based on benchmarking results.

• hashNub is faster than ordNub when there're not so many different values in the list.
• hashNub is the fastest with Text.
• intNub is faster when you work with lists of Ints.
• intNubOn is fast with the lists of type that can have fixed number representations.
• sortNub has better performance than ordNub but should be used when sorting is also needed.
• unstableNub has better performance than hashNub but doesn't save the original order.

Remove duplicates from a type-level list.

Functions to remove duplicates from a list.

Performance

To check the performance many benchmarks were done. Benchmarks were made on lists of Ints and Texts. There were two types of list to use:

• Lists which consist of many different elements
• Lists which consist of many same elements

Here are some recomendations for usage of particular functions based on benchmarking resutls.

• hashNub is faster than ordNub when there're not so many different values in the list.
• hashNub is the fastest with Text.
• sortNub has better performance than ordNub but should be used when sorting is also needed.
• unstableNub has better performance than hashNub but doesn't save the original order.