Copyright | (c) Volodymyr Yashchenko |
---|---|

License | BSD3 |

Maintainer | ualinuxcn@gmail.com |

Stability | Unstable |

Portability | portable |

Safe Haskell | Safe |

Language | Haskell2010 |

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

- complex :: Eq a => [a] -> ([a], [a], [a])
- isUnique :: Eq a => a -> [a] -> Maybe Bool
- isRepeated :: Eq a => a -> [a] -> Maybe Bool
- sortUniq :: Ord a => [a] -> [a]
- repeated :: Ord a => [a] -> [a]
- repeatedBy :: Ord a => (Int -> Bool) -> [a] -> [a]
- unique :: Ord a => [a] -> [a]
- allUnique :: Ord a => [a] -> Bool
- count :: Ord a => [a] -> [(a, Int)]
- count_ :: Ord a => [a] -> [(a, Int)]
- occurrences :: Ord a => [a] -> [(Int, [a])]
- countElem :: Eq a => a -> [a] -> Int

# Documentation

complex :: Eq a => [a] -> ([a], [a], [a]) Source #

`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

isUnique :: Eq a => a -> [a] -> Maybe Bool Source #

`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

isRepeated :: Eq a => a -> [a] -> Maybe Bool Source #

`isRepeated`

is a reverse function to `isUnique`

Since 0.4.5

sortUniq :: Ord a => [a] -> [a] Source #

`sortUniq`

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

sortUniq "foo bar" == " abfor"

repeated :: Ord a => [a] -> [a] Source #

`repeated`

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

repeated "foo bar" == "o"

repeatedBy :: Ord a => (Int -> Bool) -> [a] -> [a] Source #

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

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

unique :: Ord a => [a] -> [a] Source #

`unique`

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

unique "foo bar" == " abfr"

allUnique :: Ord a => [a] -> Bool Source #

`allUnique`

checks whether all elements of the list are unique

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

Since 0.4.7

count :: Ord a => [a] -> [(a, Int)] Source #

`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)]

count_ :: Ord a => [a] -> [(a, Int)] Source #

`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)]

occurrences :: Ord a => [a] -> [(Int, [a])] Source #

`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