Safe Haskell	None
Language	Haskell2010

Data.List.Index

Contents

Original functions
Adapted functions from Data.List
Less commonly used functions

Description

Note: a lot of these functions are available for other types (in their respective packages):

Data.Vector provides indexed and lots of other functions beginning with “i”.
Data.Map and Data.Sequence provide similar functions, but use a different naming convention (e.g. mapWithKey for maps and foldrWithIndex for sequences).
lens provides several typeclasses for indexed functions that work on maps, lists, vectors, bytestrings, and so on (in Control.Lens.Indexed), but unfortunately they are pretty slow for lists.

Synopsis

Original functions

indexed :: [a] -> [(Int, a)] #

indexed pairs each element with its index.

>>> indexed "hello"
[(0,'h'),(1,'e'),(2,'l'),(3,'l'),(4,'o')]

Subject to fusion.

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

deleteAt deletes the element at an index.

If the index is negative or exceeds list length, the original list will be returned.

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

setAt sets the element at the index.

If the index is negative or exceeds list length, the original list will be returned.

modifyAt :: Int -> (a -> a) -> [a] -> [a] #

modifyAt applies a function to the element at the index.

If the index is negative or exceeds list length, the original list will be returned.

updateAt :: Int -> (a -> Maybe a) -> [a] -> [a] #

updateAt applies a function to the element at the index, and then either replaces the element or deletes it (if the function has returned Nothing).

If the index is negative or exceeds list length, the original list will be returned.

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

insertAt inserts an element at the given position:

(insertAt i x xs) !! i == x

If the index is negative or exceeds list length, the original list will be returned. (If the index is equal to the list length, the insertion can be carried out.)

Adapted functions from Data.List

These functions mimic their counterparts in Data.List – imap, for instance, works like map but gives the index of the element to the modifying function.

Note that left folds have the index argument after the accumulator argument – that's the convention adopted by containers and vector (but not lens).

Maps

imap :: (Int -> a -> b) -> [a] -> [b] #

Subject to fusion.

imapM :: Monad m => (Int -> a -> m b) -> [a] -> m [b] #

imapM_ :: Monad m => (Int -> a -> m b) -> [a] -> m () #

Subject to fusion.

ifor :: Applicative m => [a] -> (Int -> a -> m b) -> m [b] #

ifor_ :: Applicative m => [a] -> (Int -> a -> m b) -> m () #

Subject to fusion.

Folds

ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b #

ifoldl :: forall a b. (b -> Int -> a -> b) -> b -> [a] -> b #

The index isn't the first argument of the function because that's the convention adopted by containers and vector (but not lens).

Subject to fusion.

ifoldl' :: forall a b. (b -> Int -> a -> b) -> b -> [a] -> b #

Subject to fusion.

iall :: (Int -> a -> Bool) -> [a] -> Bool #

Subject to fusion.

iany :: (Int -> a -> Bool) -> [a] -> Bool #

Subject to fusion.

iconcatMap :: (Int -> a -> [b]) -> [a] -> [b] #

Sublists

ifilter :: (Int -> a -> Bool) -> [a] -> [a] #

ipartition :: (Int -> a -> Bool) -> [a] -> ([a], [a]) #

itakeWhile :: (Int -> a -> Bool) -> [a] -> [a] #

idropWhile :: (Int -> a -> Bool) -> [a] -> [a] #

Zipping

izipWith :: (Int -> a -> b -> c) -> [a] -> [b] -> [c] #

Subject to fusion in the first argument.

izipWithM :: Applicative f => (Int -> a -> b -> f c) -> [a] -> [b] -> f [c] #

izipWithM_ :: Applicative f => (Int -> a -> b -> f c) -> [a] -> [b] -> f () #

Search

ifind :: (Int -> a -> Bool) -> [a] -> Maybe (Int, a) #

ifindIndex :: (Int -> a -> Bool) -> [a] -> Maybe Int #

ifindIndices :: (Int -> a -> Bool) -> [a] -> [Int] #

Less commonly used functions

Zipping

izipWith3 :: (Int -> a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d] #

izipWith4 :: (Int -> a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e] #

izipWith5 :: (Int -> a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] #

izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] #

izipWith7 :: (Int -> a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] #

Monadic functions

iforM :: Monad m => [a] -> (Int -> a -> m b) -> m [b] #

iforM_ :: Monad m => [a] -> (Int -> a -> m b) -> m () #

Subject to fusion.

itraverse :: Applicative m => (Int -> a -> m b) -> [a] -> m [b] #

itraverse_ :: Applicative m => (Int -> a -> m b) -> [a] -> m () #

Subject to fusion.

ireplicateM :: Applicative m => Int -> (Int -> m a) -> m [a] #

Perform a given action n times. Behaves like for_ [0..n-1], but avoids space leaks.

If you want more complicated loops (e.g. counting downwards), consider the loop package.

ireplicateM_ :: Monad m => Int -> (Int -> m a) -> m () #

NB. This function intentionally uses Monad even though Applicative is enough. That's because the transformers package didn't have an optimized definition of (*>) for StateT prior to 0.5.3.0, so for a common case of StateT this function would be 40 times slower with the Applicative constraint.

ifoldrM :: Monad m => (Int -> a -> b -> m b) -> b -> [a] -> m b #

ifoldlM :: Monad m => (b -> Int -> a -> m b) -> b -> [a] -> m b #

Subject to fusion.

Folds

ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m #

imapAccumR :: (acc -> Int -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) #

imapAccumL :: (acc -> Int -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) #