Agda.Utils.List

Utility functions for lists.

Documentation

snoc :: [a] -> a -> [a]

Append a single element at the end. Time: O(length); use only on small lists.

caseList :: [a] -> b -> (a -> [a] -> b) -> b

Case distinction for lists, with list first. Cf. ifNull.

caseListM :: Monad m => m [a] -> m b -> (a -> [a] -> m b) -> m b

Case distinction for lists, with list first. Cf. ifNull.

listCase :: b -> (a -> [a] -> b) -> [a] -> b

Case distinction for lists, with list last.

headMaybe :: [a] -> Maybe a

Head function (safe).

headWithDefault :: a -> [a] -> a

Head function (safe). Returns a default value on empty lists.

headWithDefault 42 []      = 42
headWithDefault 42 [1,2,3] = 1

tailMaybe :: [a] -> Maybe [a]

Tail function (safe).

tailWithDefault :: [a] -> [a] -> [a]

Tail function (safe). Returns a default list on empty lists.

lastMaybe :: [a] -> Maybe a

Last element (safe).

last2 :: [a] -> Maybe (a, a)

Last two elements (safe).

dropEnd :: forall a. Int -> [a] -> [a]

Drop from the end of a list. dropEnd n = reverse . drop n . reverse (Forces the whole list even for n==0.)

uncons :: [a] -> Maybe (a, [a])

Opposite of cons (:), safe.

mcons :: Maybe a -> [a] -> [a]

Maybe cons. mcons ma as = maybeToList ma ++ as

initLast :: [a] -> Maybe ([a], a)

init and last in one go, safe.

initMaybe :: [a] -> Maybe [a]

init, safe.

(!!!) :: [a] -> Int -> Maybe a

Lookup function (partially safe).

indexWithDefault :: a -> [a] -> Int -> a

Lookup function with default value for index out of range. The name is chosen akin to genericIndex.

findWithIndex :: (a -> Bool) -> [a] -> Maybe (a, Int)

Find an element satisfying a predicate and return it with its index. TODO: more efficient implementation!?

downFrom :: Integral a => a -> [a]

downFrom n = [n-1,..1,0]

updateHead :: (a -> a) -> [a] -> [a]

Update the first element of a list, if it exists.

updateLast :: (a -> a) -> [a] -> [a]

Update the last element of a list, if it exists.

updateAt :: Int -> (a -> a) -> [a] -> [a]

Update nth element of a list, if it exists. Precondition: the index is >= 0.

mapEither :: (a -> Either b c) -> [a] -> ([b], [c])

A generalized version of partition. (Cf. mapMaybe vs. filter).

deal :: (a -> Either b c) -> a -> ([b], [c]) -> ([b], [c])

spanEnd :: forall a. (a -> Bool) -> [a] -> ([a], [a])

Split off the largest suffix whose elements satisfy a predicate.

spanEnd p xs = (ys, zs) where xs = ys ++ zs and all p zs and maybe True (not . p) (lastMaybe yz).

takeWhileJust :: (a -> Maybe b) -> [a] -> [b]

A generalized version of takeWhile. (Cf. mapMaybe vs. filter).

spanJust :: (a -> Maybe b) -> [a] -> ([b], [a])

A generalized version of span.

partitionMaybe :: (a -> Maybe b) -> [a] -> ([a], [b])

Partition a list into Nothings and Justs. mapMaybe f = snd . partitionMaybe f.

filterAndRest :: (a -> Bool) -> [a] -> ([a], [a])

Like filter, but additionally return the last partition of the list where the predicate is False everywhere.

mapMaybeAndRest :: (a -> Maybe b) -> [a] -> ([b], [a])

Like mapMaybe, but additionally return the last partition of the list where the function always returns Nothing.

dropCommon :: [a] -> [b] -> ([a], [b])

Drops from both lists simultaneously until one list is empty.

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

Sublist relation.

type Prefix a = [a]

type Suffix a = [a]

stripPrefixBy :: (a -> a -> Bool) -> Prefix a -> [a] -> Maybe (Suffix a)

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

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

stripSuffix suf xs = Just pre iff xs = pre ++ suf.

type ReversedSuffix a = [a]

stripReversedSuffix :: forall a. Eq a => ReversedSuffix a -> [a] -> Maybe (Prefix a)

stripReversedSuffix rsuf xs = Just pre iff xs = pre ++ reverse suf.

data StrSufSt a

Internal state for stripping suffix.

Constructors

SSSMismatch

Error.

SSSStrip (ReversedSuffix a)

"Negative string" to remove from end. List may be empty.

SSSResult [a]

"Positive string" (result). Non-empty list.

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

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

words xs == wordsBy isSpace xs

chop :: Int -> [a] -> [[a]]

Chop up a list in chunks of a given length.

chopWhen :: (a -> Bool) -> [a] -> [[a]]

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

holes :: [a] -> [(a, [a])]

All ways of removing one element from a list.

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

Check whether a list is sorted.

Assumes that the Ord instance implements a partial order.

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

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

An optimised version of distinct.

Precondition: The list's length must fit in an Int.

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

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]

Returns an (arbitrary) representative for each list element that occurs more than once.

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

A variant of groupBy which applies the predicate to consecutive pairs.

groupOn :: Ord b => (a -> b) -> [a] -> [[a]]

groupOn f = groupBy ((==) `on` f) . sortBy (compare `on` f).

splitExactlyAt :: Integral n => n -> [a] -> Maybe ([a], [a])

splitExactlyAt n xs = Just (ys, zs) iff xs = ys ++ zs and genericLength ys = n.

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

A generalised variant of elemIndex.

zipWith' :: (a -> b -> c) -> [a] -> [b] -> Maybe [c]

Requires both lists to have the same length.

Otherwise, Nothing is returned.

zipWithKeepRest :: (a -> b -> b) -> [a] -> [b] -> [b]

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]

Efficient variant of nubBy for finite lists.

Specification:

nubOn f xs == 'nubBy' ((==) `'on'` f) xs.

uniqOn :: Ord b => (a -> b) -> [a] -> [a]

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]

Compute the common suffix of two lists.

commonPrefix :: Eq a => [a] -> [a] -> [a]

Compute the common prefix of two lists.

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

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