Safe Haskell	Safe-Inferred
Language	Haskell2010

Data.List.Safe

Contents

Safe versions of standard functions.
Generic wrapper for partial functions.
Exceptions for empty lists and negative indices.

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 for Maybe,
the empty list for '[a]',
IOException for IO,
lifted exceptions for monad transformers.

Synopsis

(++) :: [a] -> [a] -> [a]
filter :: (a -> Bool) -> [a] -> [a]
zip :: [a] -> [b] -> [(a, b)]
map :: (a -> b) -> [a] -> [b]
foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b
sum :: (Foldable t, Num a) => t a -> a
product :: (Foldable t, Num a) => t a -> a
null :: Foldable t => t a -> Bool
length :: Foldable t => t a -> Int
foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b
elem :: (Foldable t, Eq a) => a -> t a -> Bool
foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b
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]
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]
break :: (a -> Bool) -> [a] -> ([a], [a])
cycle :: [a] -> [a]
drop :: Int -> [a] -> [a]
dropWhile :: (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])
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
isSubsequenceOf :: Eq a => [a] -> [a] -> Bool
(\\) :: 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]
group :: Eq a => [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])
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

(++) :: [a] -> [a] -> [a] #

filter :: (a -> Bool) -> [a] -> [a] #

zip :: [a] -> [b] -> [(a, b)] #

map :: (a -> b) -> [a] -> [b] #

foldl' :: Foldable t => (b -> a -> b) -> b -> t a -> b #

sum :: (Foldable t, Num a) => t a -> a #

product :: (Foldable t, Num a) => t a -> a #

null :: Foldable t => t a -> Bool #

length :: Foldable t => t a -> Int #

foldr :: Foldable t => (a -> b -> b) -> b -> t a -> b #

elem :: (Foldable t, Eq a) => a -> t a -> Bool #

foldl :: Foldable t => (b -> a -> b) -> b -> t a -> b #

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] #

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] #

break :: (a -> Bool) -> [a] -> ([a], [a]) #

cycle :: [a] -> [a] #

drop :: Int -> [a] -> [a] #

dropWhile :: (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]) #

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 #

isSubsequenceOf :: Eq a => [a] -> [a] -> Bool #

(\\) :: 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] #

group :: Eq a => [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]) #

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.

foldl1' :: MonadThrow m => (a -> a -> a) -> [a] -> m a Source #

A strict version of foldl1.

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

Instances details

Exception EmptyListException Source #
Instance details Defined in Data.List.Safe Methods toException :: EmptyListException -> SomeException fromException :: SomeException -> Maybe EmptyListException displayException :: EmptyListException -> String
Read EmptyListException Source #
Instance details Defined in Data.List.Safe Methods readsPrec :: Int -> ReadS EmptyListException readList :: ReadS [EmptyListException] readPrec :: ReadPrec EmptyListException readListPrec :: ReadPrec [EmptyListException]
Show EmptyListException Source #
Instance details Defined in Data.List.Safe Methods showsPrec :: Int -> EmptyListException -> ShowS show :: EmptyListException -> String showList :: [EmptyListException] -> ShowS
Eq EmptyListException Source #
Instance details Defined in Data.List.Safe Methods (==) :: EmptyListException -> EmptyListException -> Bool (/=) :: EmptyListException -> EmptyListException -> Bool
Ord EmptyListException Source #
Instance details Defined in Data.List.Safe Methods compare :: EmptyListException -> EmptyListException -> Ordering (<) :: EmptyListException -> EmptyListException -> Bool (<=) :: EmptyListException -> EmptyListException -> Bool (>) :: EmptyListException -> EmptyListException -> Bool (>=) :: EmptyListException -> EmptyListException -> Bool max :: EmptyListException -> EmptyListException -> EmptyListException min :: EmptyListException -> EmptyListException -> EmptyListException

data NegativeIndexException Source #

Singals that an element with a negative index was accessed.

Constructors

NegativeIndexException

Instances

Instances details

Exception NegativeIndexException Source #
Instance details Defined in Data.List.Safe Methods toException :: NegativeIndexException -> SomeException fromException :: SomeException -> Maybe NegativeIndexException displayException :: NegativeIndexException -> String
Read NegativeIndexException Source #
Instance details Defined in Data.List.Safe Methods readsPrec :: Int -> ReadS NegativeIndexException readList :: ReadS [NegativeIndexException] readPrec :: ReadPrec NegativeIndexException readListPrec :: ReadPrec [NegativeIndexException]
Show NegativeIndexException Source #
Instance details Defined in Data.List.Safe Methods showsPrec :: Int -> NegativeIndexException -> ShowS show :: NegativeIndexException -> String showList :: [NegativeIndexException] -> ShowS
Eq NegativeIndexException Source #
Instance details Defined in Data.List.Safe Methods (==) :: NegativeIndexException -> NegativeIndexException -> Bool (/=) :: NegativeIndexException -> NegativeIndexException -> Bool
Ord NegativeIndexException Source #
Instance details Defined in Data.List.Safe Methods compare :: NegativeIndexException -> NegativeIndexException -> Ordering (<) :: NegativeIndexException -> NegativeIndexException -> Bool (<=) :: NegativeIndexException -> NegativeIndexException -> Bool (>) :: NegativeIndexException -> NegativeIndexException -> Bool (>=) :: NegativeIndexException -> NegativeIndexException -> Bool max :: NegativeIndexException -> NegativeIndexException -> NegativeIndexException min :: NegativeIndexException -> NegativeIndexException -> NegativeIndexException