| Copyright | (c) 2016-2019 Artyom Kazak (c) 2019-2020 Kowainik |
|---|---|
| License | MPL-2.0 |
| Maintainer | Kowainik <xrom.xkov@gmail.com> |
| Safe Haskell | Safe-Inferred |
| Language | Haskell2010 |
Data.List.Index
Description
Synopsis
- indexed :: [a] -> [(Int, a)]
- deleteAt :: Int -> [a] -> [a]
- setAt :: Int -> a -> [a] -> [a]
- modifyAt :: Int -> (a -> a) -> [a] -> [a]
- updateAt :: Int -> (a -> Maybe a) -> [a] -> [a]
- insertAt :: Int -> a -> [a] -> [a]
- imap :: (Int -> a -> b) -> [a] -> [b]
- imapM :: Monad m => (Int -> a -> m b) -> [a] -> m [b]
- imapM_ :: Monad m => (Int -> a -> m b) -> [a] -> m ()
- ifor :: Applicative m => [a] -> (Int -> a -> m b) -> m [b]
- ifor_ :: Applicative m => [a] -> (Int -> a -> m b) -> m ()
- ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b
- ifoldl :: forall a b. (b -> Int -> a -> b) -> b -> [a] -> b
- ifoldl' :: forall a b. (b -> Int -> a -> b) -> b -> [a] -> b
- iall :: (Int -> a -> Bool) -> [a] -> Bool
- iany :: (Int -> a -> Bool) -> [a] -> Bool
- iconcatMap :: (Int -> a -> [b]) -> [a] -> [b]
- 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]
- izipWith :: (Int -> a -> b -> c) -> [a] -> [b] -> [c]
- izipWithM :: Applicative f => (Int -> a -> b -> f c) -> [a] -> [b] -> f [c]
- izipWithM_ :: Applicative f => (Int -> a -> b -> f c) -> [a] -> [b] -> f ()
- ifind :: (Int -> a -> Bool) -> [a] -> Maybe (Int, a)
- ifindIndex :: (Int -> a -> Bool) -> [a] -> Maybe Int
- ifindIndices :: (Int -> a -> Bool) -> [a] -> [Int]
- 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]
- iforM :: Monad m => [a] -> (Int -> a -> m b) -> m [b]
- iforM_ :: Monad m => [a] -> (Int -> a -> m b) -> m ()
- itraverse :: Applicative m => (Int -> a -> m b) -> [a] -> m [b]
- itraverse_ :: Applicative m => (Int -> a -> m b) -> [a] -> m ()
- ireplicateM :: Applicative m => Int -> (Int -> m a) -> m [a]
- ireplicateM_ :: Monad m => Int -> (Int -> m a) -> m ()
- ifoldrM :: Monad m => (Int -> a -> b -> m b) -> b -> [a] -> m b
- ifoldlM :: Monad m => (b -> Int -> a -> m b) -> b -> [a] -> m b
- ifoldMap :: (Semigroup m, 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])
Original functions
indexed :: [a] -> [(Int, a)] Source #
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] Source #
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] Source #
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] Source #
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] Source #
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] Source #
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).
Folds
ifoldl :: forall a b. (b -> Int -> a -> b) -> b -> [a] -> b Source #
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.
iconcatMap :: (Int -> a -> [b]) -> [a] -> [b] Source #
Sublists
ipartition :: (Int -> a -> Bool) -> [a] -> ([a], [a]) Source #
itakeWhile :: (Int -> a -> Bool) -> [a] -> [a] Source #
idropWhile :: (Int -> a -> Bool) -> [a] -> [a] Source #
Zipping
izipWith :: (Int -> a -> b -> c) -> [a] -> [b] -> [c] Source #
Subject to fusion in the first argument.
izipWithM_ :: Applicative f => (Int -> a -> b -> f c) -> [a] -> [b] -> f () Source #
Search
ifindIndex :: (Int -> a -> Bool) -> [a] -> Maybe Int Source #
ifindIndices :: (Int -> a -> Bool) -> [a] -> [Int] Source #
Less commonly used functions
Zipping
izipWith6 :: (Int -> a -> b -> c -> d -> e -> f -> g) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] Source #
izipWith7 :: (Int -> a -> b -> c -> d -> e -> f -> g -> h) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f] -> [g] -> [h] Source #
Monadic functions
itraverse_ :: Applicative m => (Int -> a -> m b) -> [a] -> m () Source #
Subject to fusion.
ireplicateM :: Applicative m => Int -> (Int -> m a) -> m [a] Source #
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 () Source #
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.
Folds
imapAccumR :: (acc -> Int -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) Source #
imapAccumL :: (acc -> Int -> x -> (acc, y)) -> acc -> [x] -> (acc, [y]) Source #