Data.List.Plus

Documentation

module Data.List

catMaybes :: [Maybe a] -> [a]

The catMaybes function takes a list of Maybes and returns a list of all the Just values.

Examples

Basic usage:

>>> catMaybes [Just 1, Nothing, Just 3]
[1,3]

When constructing a list of Maybe values, catMaybes can be used to return all of the "success" results (if the list is the result of a map, then mapMaybe would be more appropriate):

>>> import Text.Read ( readMaybe )
>>> [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[Just 1,Nothing,Just 3]
>>> catMaybes $ [readMaybe x :: Maybe Int | x <- ["1", "Foo", "3"] ]
[1,3]

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

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

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

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

groupOnSort :: Ord b => (a -> b) -> [a] -> [(b, [a])]

groupOnSort' :: Ord b => (a -> (b, c)) -> [a] -> [(b, [c])]

groupBySort :: Ord b => (b -> b -> Ordering) -> (a -> b) -> [a] -> [(b, [a])]

groupUnsortedOn :: forall a b. Eq b => (a -> b) -> [a] -> [(b, [a])]

headM :: Monad m => [a] -> m a

lastElems :: Int -> [a] -> [a]

lastM :: Monad m => [a] -> m a

lookupM :: (Eq a, Monad m) => (a -> String) -> a -> [(a, b)] -> m b

makeMapping :: (Eq a, Hashable a) => [(a, b)] -> [(a, b)]

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

The mapMaybe function is a version of map which can throw out elements. In particular, the functional argument returns something of type Maybe b. If this is Nothing, no element is added on to the result list. If it is Just b, then b is included in the result list.

Examples

Using mapMaybe f x is a shortcut for catMaybes $ map f x in most cases:

>>> import Text.Read ( readMaybe )
>>> let readMaybeInt = readMaybe :: String -> Maybe Int
>>> mapMaybe readMaybeInt ["1", "Foo", "3"]
[1,3]
>>> catMaybes $ map readMaybeInt ["1", "Foo", "3"]
[1,3]

If we map the Just constructor, the entire list should be returned:

>>> mapMaybe Just [1,2,3]
[1,2,3]

maximumM :: (Monad m, Ord a) => [a] -> m a

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

Merge two sorted list so that the resulting list is sorted as well. and contains all elements from one of the lists. The length of the resulting list is the sum of the lengths of the given lists.

middle :: [a] -> Maybe a

Computes the element in the middle of the list If the list has an even number of elements, you will get the element after the middle of the list.

minimumM :: (Monad m, Ord a) => [a] -> m a

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

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

Merge the two sorted lists and remove all duplicates.

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

sconcatBy :: (Ord b, Foldable f, Semigroup s) => (a -> b) -> (a -> s) -> f a -> [(b, s)]

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

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

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

Strips as elements of a given prefix list as possible. Stops stripping if the prefix doesn't match anymore or is exhausted and returns the remaining string.

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

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