Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Data.List.Safe
Description
Operations on lists. This module re-exports all safe functions of
List
, but wraps all partial functions which may fail. As such, this
module can be imported instead of Data.List.
Partial functions are wrapped into the MonadThrow
-monad from
Control.Monad.Catch and as such, have appropriate failure cases for all
instances. E.g.:
Nothing
forMaybe
,- the empty list for '[a]',
IOException
forIO
,- lifted exceptions for monad transformers.
Synopsis
- group :: Eq a => [a] -> [[a]]
- all :: Foldable t => (a -> Bool) -> t a -> Bool
- and :: Foldable t => t Bool -> Bool
- any :: Foldable t => (a -> Bool) -> t a -> Bool
- concat :: Foldable t => t [a] -> [a]
- concatMap :: Foldable t => (a -> [b]) -> t a -> [b]
- elem :: (Foldable t, Eq a) => a -> t a -> Bool
- foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
- foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
- length :: Foldable t => t a -> Int
- null :: Foldable t => t a -> Bool
- product :: (Foldable t, Num a) => t a -> a
- sum :: (Foldable t, Num a) => t a -> a
- foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
- notElem :: (Foldable t, Eq a) => a -> t a -> Bool
- or :: Foldable t => t Bool -> Bool
- lines :: String -> [String]
- unlines :: [String] -> String
- unwords :: [String] -> String
- words :: String -> [String]
- (++) :: [a] -> [a] -> [a]
- map :: (a -> b) -> [a] -> [b]
- break :: (a -> Bool) -> [a] -> ([a], [a])
- cycle :: HasCallStack => [a] -> [a]
- drop :: Int -> [a] -> [a]
- dropWhile :: (a -> Bool) -> [a] -> [a]
- filter :: (a -> Bool) -> [a] -> [a]
- iterate :: (a -> a) -> a -> [a]
- lookup :: Eq a => a -> [(a, b)] -> Maybe b
- repeat :: a -> [a]
- replicate :: Int -> a -> [a]
- reverse :: [a] -> [a]
- scanl :: (b -> a -> b) -> b -> [a] -> [b]
- scanl1 :: (a -> a -> a) -> [a] -> [a]
- scanr :: (a -> b -> b) -> b -> [a] -> [b]
- scanr1 :: (a -> a -> a) -> [a] -> [a]
- span :: (a -> Bool) -> [a] -> ([a], [a])
- splitAt :: Int -> [a] -> ([a], [a])
- take :: Int -> [a] -> [a]
- takeWhile :: (a -> Bool) -> [a] -> [a]
- unzip :: [(a, b)] -> ([a], [b])
- unzip3 :: [(a, b, c)] -> ([a], [b], [c])
- zip :: [a] -> [b] -> [(a, b)]
- zip3 :: [a] -> [b] -> [c] -> [(a, b, c)]
- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
- zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
- find :: Foldable t => (a -> Bool) -> t a -> Maybe a
- (\\) :: Eq a => [a] -> [a] -> [a]
- delete :: Eq a => a -> [a] -> [a]
- deleteBy :: (a -> a -> Bool) -> a -> [a] -> [a]
- deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- dropWhileEnd :: (a -> Bool) -> [a] -> [a]
- elemIndex :: Eq a => a -> [a] -> Maybe Int
- elemIndices :: Eq a => a -> [a] -> [Int]
- findIndex :: (a -> Bool) -> [a] -> Maybe Int
- findIndices :: (a -> Bool) -> [a] -> [Int]
- genericDrop :: Integral i => i -> [a] -> [a]
- genericIndex :: Integral i => [a] -> i -> a
- genericLength :: Num i => [a] -> i
- genericReplicate :: Integral i => i -> a -> [a]
- genericSplitAt :: Integral i => i -> [a] -> ([a], [a])
- genericTake :: Integral i => i -> [a] -> [a]
- groupBy :: (a -> a -> Bool) -> [a] -> [[a]]
- inits :: [a] -> [[a]]
- insert :: Ord a => a -> [a] -> [a]
- insertBy :: (a -> a -> Ordering) -> a -> [a] -> [a]
- intercalate :: [a] -> [[a]] -> [a]
- intersect :: Eq a => [a] -> [a] -> [a]
- intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- intersperse :: a -> [a] -> [a]
- isInfixOf :: Eq a => [a] -> [a] -> Bool
- isPrefixOf :: Eq a => [a] -> [a] -> Bool
- isSuffixOf :: Eq a => [a] -> [a] -> Bool
- nub :: Eq a => [a] -> [a]
- nubBy :: (a -> a -> Bool) -> [a] -> [a]
- partition :: (a -> Bool) -> [a] -> ([a], [a])
- permutations :: [a] -> [[a]]
- singleton :: a -> [a]
- sort :: Ord a => [a] -> [a]
- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
- sortOn :: Ord b => (a -> b) -> [a] -> [a]
- stripPrefix :: Eq a => [a] -> [a] -> Maybe [a]
- subsequences :: [a] -> [[a]]
- tails :: [a] -> [[a]]
- transpose :: [[a]] -> [[a]]
- unfoldr :: (b -> Maybe (a, b)) -> b -> [a]
- union :: Eq a => [a] -> [a] -> [a]
- unionBy :: (a -> a -> Bool) -> [a] -> [a] -> [a]
- unzip4 :: [(a, b, c, d)] -> ([a], [b], [c], [d])
- unzip5 :: [(a, b, c, d, e)] -> ([a], [b], [c], [d], [e])
- unzip6 :: [(a, b, c, d, e, f)] -> ([a], [b], [c], [d], [e], [f])
- unzip7 :: [(a, b, c, d, e, f, g)] -> ([a], [b], [c], [d], [e], [f], [g])
- zip4 :: [a] -> [b] -> [c] -> [d] -> [(a, b, c, d)]
- zip5 :: [a] -> [b] -> [c] -> [d] -> [e] -> [(a, b, c, d, e)]
- zip6 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [(a, b, c, d, e, f)]
- zip7 :: [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [(a, b, c, d, e, f, g)]
- zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
- zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
- zipWith6 :: (a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g]
- zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h]
- mapAccumL :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- mapAccumR :: Traversable t => (s -> a -> (s, b)) -> s -> t a -> (s, t b)
- iterate' :: (a -> a) -> a -> [a]
- scanl' :: (b -> a -> b) -> b -> [a] -> [b]
- uncons :: [a] -> Maybe (a, [a])
- isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
- head :: MonadThrow m => [a] -> m a
- last :: MonadThrow m => [a] -> m a
- tail :: MonadThrow m => [a] -> m [a]
- init :: MonadThrow m => [a] -> m [a]
- foldl1 :: MonadThrow m => (a -> a -> a) -> [a] -> m a
- foldl1' :: MonadThrow m => (a -> a -> a) -> [a] -> m a
- foldr1 :: MonadThrow m => (a -> a -> a) -> [a] -> m a
- maximum :: (MonadThrow m, Ord a) => [a] -> m a
- minimum :: (MonadThrow m, Ord a) => [a] -> m a
- maximumBy :: MonadThrow m => (a -> a -> Ordering) -> [a] -> m a
- minimumBy :: MonadThrow m => (a -> a -> Ordering) -> [a] -> m a
- (!!) :: (MonadThrow m, Integral n) => [a] -> n -> m a
- wrap :: MonadThrow m => ([a] -> b) -> [a] -> m b
- data EmptyListException = EmptyListException
- data NegativeIndexException = NegativeIndexException
Documentation
deleteFirstsBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #
dropWhileEnd :: (a -> Bool) -> [a] -> [a] #
elemIndices :: Eq a => a -> [a] -> [Int] #
findIndices :: (a -> Bool) -> [a] -> [Int] #
genericDrop :: Integral i => i -> [a] -> [a] #
genericIndex :: Integral i => [a] -> i -> a #
genericLength :: Num i => [a] -> i #
genericReplicate :: Integral i => i -> a -> [a] #
genericSplitAt :: Integral i => i -> [a] -> ([a], [a]) #
genericTake :: Integral i => i -> [a] -> [a] #
intercalate :: [a] -> [[a]] -> [a] #
intersectBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] #
intersperse :: a -> [a] -> [a] #
isPrefixOf :: Eq a => [a] -> [a] -> Bool #
isSuffixOf :: Eq a => [a] -> [a] -> Bool #
permutations :: [a] -> [[a]] #
stripPrefix :: Eq a => [a] -> [a] -> Maybe [a] #
subsequences :: [a] -> [[a]] #
zipWith7 :: (a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] #
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool #
Safe versions of standard functions.
head :: MonadThrow m => [a] -> m a Source #
Extract the first element of a list. Empty lists throw an EmptyListException
.
last :: MonadThrow m => [a] -> m a Source #
Extract the last element of a list. Empty lists throw an EmptyListException
.
tail :: MonadThrow m => [a] -> m [a] Source #
Extract the elements after the head of a list.
Empty lists throw an EmptyListException
.
init :: MonadThrow m => [a] -> m [a] Source #
Return all the elements of a list except the last one.
Empty lists throw an EmptyListException
.
foldl1 :: MonadThrow m => (a -> a -> a) -> [a] -> m a Source #
foldl1
is a variant of foldl
that has no starting value, and thus must
be applied to non-empty lists. Empty lists throw an EmptyListException
.
foldr1 :: MonadThrow m => (a -> a -> a) -> [a] -> m a Source #
foldr1
is a variant of foldr
that has no starting value, and thus must
be applied to non-empty lists. Empty lists throw an EmptyListException
.
maximum :: (MonadThrow m, Ord a) => [a] -> m a Source #
maximum
returns the maximum value from a list, which must be non-empty,
finite, and of an ordered type. It is a special case of maximumBy
, which
allows the programmer to supply their own comparison function.
Empty lists throw an EmptyListException
.
minimum :: (MonadThrow m, Ord a) => [a] -> m a Source #
minimum
returns the maximum value from a list, which must be non-empty,
finite, and of an ordered type. It is a special case of minimumBy
, which
allows the programmer to supply their own comparison function.
Empty lists throw an EmptyListException
.
maximumBy :: MonadThrow m => (a -> a -> Ordering) -> [a] -> m a Source #
The maximumBy
function takes a comparison function and a list and returns
the greatest element of the list by the comparison function. The list must
be finite and non-empty. Empty lists throw an EmptyListException
.
minimumBy :: MonadThrow m => (a -> a -> Ordering) -> [a] -> m a Source #
The minimumBy
function takes a comparison function and a list and returns
the least element of the list by the comparison function. The list must
be finite and non-empty. Empty lists throw an EmptyListException
.
(!!) :: (MonadThrow m, Integral n) => [a] -> n -> m a Source #
List index (subscript) operator, starting from 0. Indices larger than
length xs - 1
throw an EmptyListException
, negative indices throw
an NegativeIndexException
.
Generic wrapper for partial functions.
wrap :: MonadThrow m => ([a] -> b) -> [a] -> m b Source #
Takes a function that requires a non-empty list and wraps it in an instance
of MonadThrow
. For empty lists, an EmptyListException
is thrown.
Exceptions for empty lists and negative indices.
These are the only two exceptions that will be thrown.
data EmptyListException Source #
Signals that the list was empty or contained too few elements (in the case or access by index).
Constructors
EmptyListException |
Instances
data NegativeIndexException Source #
Singals that an element with a negative index was accessed.
Constructors
NegativeIndexException |