| 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.:
NothingforMaybe,- the empty list for '[a]',
IOExceptionforIO,- 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 |