Safe Haskell | None |
---|---|
Language | Haskell2010 |
Utility functions for lists.
Synopsis
- caseList :: [a] -> b -> (a -> [a] -> b) -> b
- listCase :: b -> (a -> [a] -> b) -> [a] -> b
- headMaybe :: [a] -> Maybe a
- headWithDefault :: a -> [a] -> a
- lastMaybe :: [a] -> Maybe a
- last2 :: [a] -> Maybe (a, a)
- uncons :: [a] -> Maybe (a, [a])
- mcons :: Maybe a -> [a] -> [a]
- initLast :: [a] -> Maybe ([a], a)
- (!!!) :: [a] -> Int -> Maybe a
- downFrom :: Integral a => a -> [a]
- updateHead :: (a -> a) -> [a] -> [a]
- updateLast :: (a -> a) -> [a] -> [a]
- updateAt :: Int -> (a -> a) -> [a] -> [a]
- mapEither :: (a -> Either b c) -> [a] -> ([b], [c])
- deal :: (a -> Either b c) -> a -> ([b], [c]) -> ([b], [c])
- takeWhileJust :: (a -> Maybe b) -> [a] -> [b]
- spanJust :: (a -> Maybe b) -> [a] -> ([b], [a])
- partitionMaybe :: (a -> Maybe b) -> [a] -> ([a], [b])
- filterAndRest :: (a -> Bool) -> [a] -> ([a], [a])
- mapMaybeAndRest :: (a -> Maybe b) -> [a] -> ([b], [a])
- dropCommon :: [a] -> [b] -> ([a], [b])
- isSublistOf :: Eq a => [a] -> [a] -> Bool
- type Prefix a = [a]
- type Suffix a = [a]
- stripPrefixBy :: (a -> a -> Bool) -> Prefix a -> [a] -> Maybe (Suffix a)
- data PreOrSuffix a
- preOrSuffix :: Eq a => [a] -> [a] -> PreOrSuffix a
- wordsBy :: (a -> Bool) -> [a] -> [[a]]
- chop :: Int -> [a] -> [[a]]
- chopWhen :: (a -> Bool) -> [a] -> [[a]]
- holes :: [a] -> [(a, [a])]
- sorted :: Ord a => [a] -> Bool
- distinct :: Eq a => [a] -> Bool
- fastDistinct :: Ord a => [a] -> Bool
- allEqual :: Eq a => [a] -> Bool
- duplicates :: Ord a => [a] -> [a]
- groupBy' :: (a -> a -> Bool) -> [a] -> [[a]]
- groupOn :: Ord b => (a -> b) -> [a] -> [[a]]
- splitExactlyAt :: Integral n => n -> [a] -> Maybe ([a], [a])
- genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe i
- zipWith' :: (a -> b -> c) -> [a] -> [b] -> Maybe [c]
- zipWithKeepRest :: (a -> b -> b) -> [a] -> [b] -> [b]
- nubOn :: Ord b => (a -> b) -> [a] -> [a]
- uniqOn :: Ord b => (a -> b) -> [a] -> [a]
- commonSuffix :: Eq a => [a] -> [a] -> [a]
- commonPrefix :: Eq a => [a] -> [a] -> [a]
- editDistanceSpec :: Eq a => [a] -> [a] -> Int
- editDistance :: Eq a => [a] -> [a] -> Int
Documentation
caseList :: [a] -> b -> (a -> [a] -> b) -> b Source #
Case distinction for lists, with list first.
Cf. ifNull
.
headWithDefault :: a -> [a] -> a Source #
Head function (safe). Returns a value on empty lists.
headWithDefault 42 [] = 42 headWithDefault 42 [1,2,3] = 1
updateHead :: (a -> a) -> [a] -> [a] Source #
Update the first element of a list, if it exists.
updateLast :: (a -> a) -> [a] -> [a] Source #
Update the last element of a list, if it exists.
updateAt :: Int -> (a -> a) -> [a] -> [a] Source #
Update nth element of a list, if it exists. Precondition: the index is >= 0.
mapEither :: (a -> Either b c) -> [a] -> ([b], [c]) Source #
A generalized version of partition
.
(Cf. mapMaybe
vs. filter
).
takeWhileJust :: (a -> Maybe b) -> [a] -> [b] Source #
A generalized version of takeWhile
.
(Cf. mapMaybe
vs. filter
).
partitionMaybe :: (a -> Maybe b) -> [a] -> ([a], [b]) Source #
filterAndRest :: (a -> Bool) -> [a] -> ([a], [a]) Source #
Like filter
, but additionally return the last partition
of the list where the predicate is False
everywhere.
mapMaybeAndRest :: (a -> Maybe b) -> [a] -> ([b], [a]) Source #
Like mapMaybe
, but additionally return the last partition
of the list where the function always returns Nothing
.
dropCommon :: [a] -> [b] -> ([a], [b]) Source #
Drops from both lists simultaneously until one list is empty.
isSublistOf :: Eq a => [a] -> [a] -> Bool Source #
Sublist relation.
stripPrefixBy :: (a -> a -> Bool) -> Prefix a -> [a] -> Maybe (Suffix a) Source #
Check if a list has a given prefix. If so, return the list minus the prefix.
data PreOrSuffix a Source #
Result of preOrSuffix
.
preOrSuffix :: Eq a => [a] -> [a] -> PreOrSuffix a Source #
Compare lists with respect to prefix partial order.
wordsBy :: (a -> Bool) -> [a] -> [[a]] Source #
Split a list into sublists. Generalisation of the prelude function
words
.
words xs == wordsBy isSpace xs
chopWhen :: (a -> Bool) -> [a] -> [[a]] Source #
Chop a list at the positions when the predicate holds. Contrary to
wordsBy
, consecutive separator elements will result in an empty segment
in the result.
> intercalate [x] (chopWhen (== x) xs) == xs
sorted :: Ord a => [a] -> Bool Source #
Check whether a list is sorted.
Assumes that the Ord
instance implements a partial order.
distinct :: Eq a => [a] -> Bool Source #
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] -> Bool Source #
allEqual :: Eq a => [a] -> Bool Source #
Checks if all the elements in the list are equal. Assumes that
the Eq
instance stands for an equivalence relation.
duplicates :: Ord a => [a] -> [a] Source #
Returns an (arbitrary) representative for each list element that occurs more than once.
groupBy' :: (a -> a -> Bool) -> [a] -> [[a]] Source #
A variant of groupBy
which applies the predicate to consecutive
pairs.
splitExactlyAt :: Integral n => n -> [a] -> Maybe ([a], [a]) Source #
splitExactlyAt n xs = Just (ys, zs)
iff xs = ys ++ zs
and genericLength ys = n
.
genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe i Source #
A generalised variant of elemIndex
.
zipWith' :: (a -> b -> c) -> [a] -> [b] -> Maybe [c] Source #
Requires both lists to have the same length.
Otherwise, Nothing
is returned.
zipWithKeepRest :: (a -> b -> b) -> [a] -> [b] -> [b] Source #
Like zipWith
but keep the rest of the second list as-is
(in case the second list is longer).
zipWithKeepRest f as bs == zipWith f as bs ++ drop (length as) bs
nubOn :: Ord b => (a -> b) -> [a] -> [a] Source #
Efficient variant of nubBy
for finite lists.
Specification:
nubOn f xs == 'nubBy' ((==) `'on'` f) xs.
uniqOn :: Ord b => (a -> b) -> [a] -> [a] Source #
Efficient variant of nubBy
for finite lists.
Specification: For each list xs
there is a list ys
which is a
permutation of xs
such that
uniqOn f xs == 'nubBy' ((==) `'on'` f) ys.
Furthermore
List.sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs.
commonSuffix :: Eq a => [a] -> [a] -> [a] Source #
Compute the common suffix of two lists.
commonPrefix :: Eq a => [a] -> [a] -> [a] Source #
Compute the common prefix of two lists.
editDistanceSpec :: Eq a => [a] -> [a] -> Int Source #
editDistance :: Eq a => [a] -> [a] -> Int Source #