Data.List.Extra

This module extends Data.List with extra functions of a similar nature. The package also exports the existing Data.List functions. Some of the names and semantics were inspired by the text package.

Documentation

module Data.List

lower :: String -> String

upper :: String -> String

trim :: String -> String

trimLeft :: String -> String

trimRight :: String -> String

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

word1 :: String -> (String, String)

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

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

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

groupSort :: Ord k => [(k, v)] -> [(k, [v])]

groupSortOn :: Ord a => (k -> a) -> [(k, v)] -> [(k, [v])]

nubOn :: Eq b => (a -> b) -> [a] -> [a]

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

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

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

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

rep :: Eq a => a -> a -> a -> a

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

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

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

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

takeEnd :: Int -> [a] -> [a]

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

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

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

The dropWhileEnd function drops the largest suffix of a list in which the given predicate holds for all elements. For example:

 dropWhileEnd isSpace "foo\n" == "foo"
 dropWhileEnd isSpace "foo bar" == "foo bar"
 dropWhileEnd isSpace ("foo\n" ++ undefined) == "foo" ++ undefined

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

stripSuffix :: Eq a => [a] -> [a] -> Maybe [a]

Return the prefix of the second string if its suffix matches the entire first string.

Examples:

 stripSuffix "bar" "foobar" == Just "foo"
 stripSuffix ""    "baz"    == Just "baz"
 stripSuffix "foo" "quux"   == Nothing

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

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

mergeBy :: (a -> a -> Ordering) -> [a] -> [a] -> [a]

replace :: String -> String -> String -> String

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

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

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

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

Find the first instance of needle in haystack. The first element of the returned tuple is the prefix of haystack before needle is matched. The second is the remainder of haystack, starting with the match.

Examples:

 breakOn "::" "a::b::c" == ("a", "::b::c")
 breakOn "/" "foobar"   == ("foobar", "")

Laws:

 \needle haystack -> let (prefix,match) = breakOn needle haystack in prefix ++ match == haystack

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

Similar to breakOn, but searches from the end of the string.

The first element of the returned tuple is the prefix of haystack up to and including the last match of needle. The second is the remainder of haystack, following the match.

 breakOnEnd "::" "a::b::c" == ("a::b::", "c")

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

Break a list into pieces separated by the first list argument, consuming the delimiter. An empty delimiter is invalid, and will cause an error to be raised.

Examples:

 splitOn "\r\n" "a\r\nb\r\nd\r\ne" == ["a","b","d","e"]
 splitOn "aaa"  "aaaXaaaXaaaXaaa"  == ["","X","X","X",""]
 splitOn "x"    "x"                == ["",""]
 splitOn "x"    ""                 == [""]

and

 \s x -> s /= "" ==> intercalate s (splitOn s x) == x
 \c x -> splitOn [c] x                           == split (==c) x

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

Splits a list into components delimited by separators, where the predicate returns True for a separator element. The resulting components do not contain the separators. Two adjacent separators result in an empty component in the output. eg.

 split (=='a') "aabbaca" == ["","","bb","c",""]
 split (=='a') ""        == [""]

chunksOf :: Int -> [a] -> [[a]]