ModuleUnique-0.4.7.9Haskell2010

Data.List.Unique

Library provides the functions to find unique and duplicate elements in the list

valueuniq :: Eq b => [b] -> [b]

uniq behaves the same as unix uniq utility does (without cli additional options)

uniq "1121331" == "12131"

valuecomplex :: Eq a => [a] -> ([a], [a], [a])

complex function is a complex investigation of the list. It returns triple:

the first - all elements with removed duplicates (like sortUniq but the result is not sorted)
the second - the elements that are repeated at least once in the list (result is the same as repeated but not sorted)
the third - the unique elements that do not have duplicates (result is the same as unique but not sorted)

complex does not sort the resulted elements of triple as well as it can be used for types that does not have Ord instance.

Anyway, it's better to use sortUniq, repeated and unique instead of complex when type a has Ord instance.

complex "This is the test line" == ("This teln","is hte","Tln")

Since 0.4.4

valueisUnique :: Eq a => a -> [a] -> Maybe Bool

isUnique function is to check whether the given element is unique in the list or not.

It returns Nothing when the element does not present in the list. Examples:

isUnique 'f' "foo bar" == Just True
isUnique 'o' "foo bar" == Just False
isUnique '!' "foo bar" == Nothing

Since 0.4.5

valueisRepeated :: Eq a => a -> [a] -> Maybe Bool

isRepeated is a reverse function to isUnique

Since 0.4.5

valuesortUniq :: Ord a => [a] -> [a]

sortUniq sorts the list and removes the duplicates of elements. Example:

sortUniq "foo bar" == " abfor"

valuerepeated :: Ord a => [a] -> [a]

repeated finds only the elements that are present more than once in the list. Example:

repeated  "foo bar" == "o"

valuerepeatedBy :: Ord a => (Int -> Bool) -> [a] -> [a]

The repeatedBy function behaves just like repeated, except it uses a user-supplied equality predicate.

repeatedBy (>2) "This is the test line" == " eist"

valueunique :: Ord a => [a] -> [a]

unique gets only unique elements, that do not have duplicates. It sorts them. Example:

unique  "foo bar" == " abfr"

valueallUnique :: Ord a => [a] -> Bool

allUnique checks whether all elements of the list are unique

allUnique "foo bar" == False
allUnique ['a'..'z'] == True
allUnique [] == True (!)

Since 0.4.7

valuecount :: Ord a => [a] -> [(a, Int)]

count of each element in the list, it sorts by keys (elements). Example:

count "foo bar" == [(' ',1),('a',1),('b',1),('f',1),('o',2),('r',1)]

valuecount_ :: Ord a => [a] -> [(a, Int)]

count_ of each elements in the list, it sorts by their number. Example:

count_ "foo bar" == [(' ',1),('a',1),('b',1),('f',1),('r',1),('o',2)]

valueoccurrences :: Ord a => [a] -> [(Int, [a])]

occurrences like count or count_ but shows the list of elements that occur X times

occurrences "This is the test line" == [(1,"Tln"),(2,"h"),(3,"eist"),(4," ")]

Since 0.4.4

valuecountElem :: Eq a => a -> [a] -> Int

countElem gets the number of occurrences of the specified element. Example:

countElem 'o' "foo bar" == 2