Safe Haskell | Safe-Infered |
---|

Utitlity functions on lists.

- mhead :: [a] -> Maybe a
- isSublistOf :: Eq a => [a] -> [a] -> Bool
- type Prefix a = [a]
- type Suffix a = [a]
- maybePrefixMatch :: Eq a => Prefix a -> [a] -> Maybe (Suffix a)
- wordsBy :: (a -> Bool) -> [a] -> [[a]]
- chop :: Int -> [a] -> [[a]]
- holes :: [a] -> [(a, [a])]
- distinct :: Eq a => [a] -> Bool
- fastDistinct :: Ord a => [a] -> Bool
- prop_distinct_fastDistinct :: [Integer] -> Bool
- allEqual :: Eq a => [a] -> Bool
- groupBy' :: (a -> a -> Bool) -> [a] -> [[a]]
- prop_groupBy' :: (Bool -> Bool -> Bool) -> [Bool] -> Property
- groupOn :: Ord b => (a -> b) -> [a] -> [[a]]
- extractNthElement' :: Integral i => i -> [a] -> ([a], a, [a])
- extractNthElement :: Integral i => i -> [a] -> (a, [a])
- prop_extractNthElement :: Integer -> [Integer] -> Property
- genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe i
- prop_genericElemIndex :: Integer -> [Integer] -> Property
- zipWith' :: (a -> b -> c) -> [a] -> [b] -> [c]
- prop_zipWith' :: (Integer -> Integer -> Integer) -> Property
- uniqBy :: Ord b => (a -> b) -> [a] -> [a]
- prop_uniqBy :: [Integer] -> Bool
- tests :: IO Bool

# Documentation

isSublistOf :: Eq a => [a] -> [a] -> BoolSource

Sublist relation.

maybePrefixMatch :: Eq a => Prefix a -> [a] -> Maybe (Suffix a)Source

Check if a list has a given prefix. If so, return the list minus the prefix.

wordsBy :: (a -> Bool) -> [a] -> [[a]]Source

Split a list into sublists. Generalisation of the prelude function
`words`

.

words xs == wordsBy isSpace xs

distinct :: Eq a => [a] -> BoolSource

Check whether all elements in a list are distinct from each
other. Assumes that the `Eq`

instance stands for an equivalence
relation.

fastDistinct :: Ord a => [a] -> BoolSource

allEqual :: Eq a => [a] -> BoolSource

Checks if all the elements in the list are equal. Assumes that
the `Eq`

instance stands for an equivalence relation.

groupBy' :: (a -> a -> Bool) -> [a] -> [[a]]Source

A variant of `groupBy`

which applies the predicate to consecutive
pairs.

extractNthElement' :: Integral i => i -> [a] -> ([a], a, [a])Source

gives the `extractNthElement`

n xs`n`

-th element in `xs`

(counting from 0), plus the remaining elements (preserving order).

extractNthElement :: Integral i => i -> [a] -> (a, [a])Source

prop_extractNthElement :: Integer -> [Integer] -> PropertySource

genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe iSource

prop_genericElemIndex :: Integer -> [Integer] -> PropertySource

uniqBy :: Ord b => (a -> b) -> [a] -> [a]Source

Efficient version of nub that sorts the list first. The tag function is assumed to be cheap. If it isn't pair up the elements with their tags and call uniqBy fst (or snd).

prop_uniqBy :: [Integer] -> BoolSource