Control.Lens.IndexedFold

Indexed Folds

type IndexedFold i a c = forall k f. (Indexed i k, Applicative f, Gettable f) => k (c -> f c) (a -> f a)

Every IndexedFold is a valid Fold.

Consuming Indexed Folds

ifoldMapOf :: IndexedGetting i m a c -> (i -> c -> m) -> a -> m

Fold an IndexedFold or IndexedTraversal by mapping indices and values to an arbitrary Monoid with access to the index i.

When you don't need access to the index then foldMapOf is more flexible in what it accepts.

foldMapOf l = ifoldMapOf l . const

 ifoldMapOf ::             IndexedGetter i a c          -> (i -> c -> m) -> a -> m
 ifoldMapOf :: Monoid m => IndexedFold i a c            -> (i -> c -> m) -> a -> m
 ifoldMapOf ::             SimpleIndexedLens i a c      -> (i -> c -> m) -> a -> m
 ifoldMapOf :: Monoid m => SimpleIndexedTraversal i a c -> (i -> c -> m) -> a -> m

ifoldrOf :: IndexedGetting i (Endo e) a c -> (i -> c -> e -> e) -> e -> a -> e

Right-associative fold of parts of a structure that are viewed through an IndexedFold or IndexedTraversal with access to the index i.

When you don't need access to the index then foldrOf is more flexible in what it accepts.

foldrOf l = ifoldrOf l . const

 ifoldrOf :: IndexedGetter i a c          -> (i -> c -> e -> e) -> e -> a -> e
 ifoldrOf :: IndexedFold i a c            -> (i -> c -> e -> e) -> e -> a -> e
 ifoldrOf :: SimpleIndexedLens i a c      -> (i -> c -> e -> e) -> e -> a -> e
 ifoldrOf :: SimpleIndexedTraversal i a c -> (i -> c -> e -> e) -> e -> a -> e

ifoldlOf :: IndexedGetting i (Dual (Endo e)) a c -> (i -> e -> c -> e) -> e -> a -> e

Left-associative fold of the parts of a structure that are viewed through an IndexedFold or IndexedTraversal with access to the index i.

When you don't need access to the index then foldlOf is more flexible in what it accepts.

foldlOf l = ifoldlOf l . const

 ifoldlOf :: IndexedGetter i a c          -> (i -> e -> c -> e) -> e -> a -> e
 ifoldlOf :: IndexedFold i a c            -> (i -> e -> c -> e) -> e -> a -> e
 ifoldlOf :: SimpleIndexedLens i a c      -> (i -> e -> c -> e) -> e -> a -> e
 ifoldlOf :: SimpleIndexedTraversal i a c -> (i -> e -> c -> e) -> e -> a -> e

ianyOf :: IndexedGetting i Any a c -> (i -> c -> Bool) -> a -> Bool

Return whether or not any element viewed through an IndexedFold or IndexedTraversal satisfy a predicate, with access to the index i.

When you don't need access to the index then anyOf is more flexible in what it accepts.

anyOf l = ianyOf l . const

 ianyOf :: IndexedGetter i a c          -> (i -> c -> Bool) -> a -> Bool
 ianyOf :: IndexedFold i a c            -> (i -> c -> Bool) -> a -> Bool
 ianyOf :: SimpleIndexedLens i a c      -> (i -> c -> Bool) -> a -> Bool
 ianyOf :: SimpleIndexedTraversal i a c -> (i -> c -> Bool) -> a -> Bool

iallOf :: IndexedGetting i All a c -> (i -> c -> Bool) -> a -> Bool

Return whether or not all elements viewed through an IndexedFold or IndexedTraversal satisfy a predicate, with access to the index i.

When you don't need access to the index then allOf is more flexible in what it accepts.

allOf l = iallOf l . const

 iallOf :: IndexedGetter i a c          -> (i -> c -> Bool) -> a -> Bool
 iallOf :: IndexedFold i a c            -> (i -> c -> Bool) -> a -> Bool
 iallOf :: SimpleIndexedLens i a c      -> (i -> c -> Bool) -> a -> Bool
 iallOf :: SimpleIndexedTraversal i a c -> (i -> c -> Bool) -> a -> Bool

itraverseOf_ :: Functor f => IndexedGetting i (Traversed f) a c -> (i -> c -> f e) -> a -> f ()

Traverse the targets of an IndexedFold or IndexedTraversal with access to the index i, discarding the results.

When you don't need access to the index then traverseOf_ is more flexible in what it accepts.

traverseOf_ l = itraverseOf l . const

 itraverseOf_ :: Functor f     => IndexedGetter i a c          -> (i -> c -> f e) -> a -> f ()
 itraverseOf_ :: Applicative f => IndexedFold i a c            -> (i -> c -> f e) -> a -> f ()
 itraverseOf_ :: Functor f     => SimpleIndexedLens i a c      -> (i -> c -> f e) -> a -> f ()
 itraverseOf_ :: Applicative f => SimpleIndexedTraversal i a c -> (i -> c -> f e) -> a -> f ()

iforOf_ :: Functor f => IndexedGetting i (Traversed f) a c -> a -> (i -> c -> f e) -> f ()

Traverse the targets of an IndexedFold or IndexedTraversal with access to the index, discarding the results (with the arguments flipped).

iforOf_ = flip . itraverseOf_

When you don't need access to the index then forOf_ is more flexible in what it accepts.

forOf_ l a = iforOf l a . const

 iforOf_ :: Functor f     => IndexedGetter i a c          -> a -> (i -> c -> f e) -> f ()
 iforOf_ :: Applicative f => IndexedFold i a c            -> a -> (i -> c -> f e) -> f ()
 iforOf_ :: Functor f     => SimpleIndexedLens i a c      -> a -> (i -> c -> f e) -> f ()
 iforOf_ :: Applicative f => SimpleIndexedTraversal i a c -> a -> (i -> c -> f e) -> f ()

imapMOf_ :: Monad m => IndexedGetting i (Sequenced m) a c -> (i -> c -> m e) -> a -> m ()

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results.

When you don't need access to the index then mapMOf_ is more flexible in what it accepts.

mapMOf_ l = imapMOf l . const

 imapMOf_ :: Monad m => IndexedGetter i a c          -> (i -> c -> m e) -> a -> m ()
 imapMOf_ :: Monad m => IndexedFold i a c            -> (i -> c -> m e) -> a -> m ()
 imapMOf_ :: Monad m => SimpleIndexedLens i a c      -> (i -> c -> m e) -> a -> m ()
 imapMOf_ :: Monad m => SimpleIndexedTraversal i a c -> (i -> c -> m e) -> a -> m ()

iforMOf_ :: Monad m => IndexedGetting i (Sequenced m) a c -> a -> (i -> c -> m e) -> m ()

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results (with the arguments flipped).

iforMOf_ = flip . imapMOf_

When you don't need access to the index then forMOf_ is more flexible in what it accepts.

forMOf_ l a = iforMOf l a . const

 iforMOf_ :: Monad m => IndexedGetter i a c          -> a -> (i -> c -> m e) -> m ()
 iforMOf_ :: Monad m => IndexedFold i a c            -> a -> (i -> c -> m e) -> m ()
 iforMOf_ :: Monad m => SimpleIndexedLens i a c      -> a -> (i -> c -> m e) -> m ()
 iforMOf_ :: Monad m => SimpleIndexedTraversal i a c -> a -> (i -> c -> m e) -> m ()

iconcatMapOf :: IndexedGetting i [e] a c -> (i -> c -> [e]) -> a -> [e]

Concatenate the results of a function of the elements of an IndexedFold or IndexedTraversal with access to the index.

When you don't need access to the index then concatMapOf_ is more flexible in what it accepts.

concatMapOf_ l = iconcatMapMOf l . const

 iconcatMapOf :: IndexedGetter i a c          -> (i -> c -> [e]) -> a -> [e]
 iconcatMapOf :: IndexedFold i a c            -> (i -> c -> [e]) -> a -> [e]
 iconcatMapOf :: SimpleIndexedLens i a c      -> (i -> c -> [e]) -> a -> [e]
 iconcatMapOf :: SimpleIndexedTraversal i a c -> (i -> c -> [e]) -> a -> [e]

ifindOf :: IndexedGetting i (First (i, c)) a c -> (i -> c -> Bool) -> a -> Maybe (i, c)

The findOf function takes an IndexedFold or IndexedTraversal, a predicate that is also supplied the index, a structure and returns the left-most element of the structure matching the predicate, or Nothing if there is no such element.

When you don't need access to the index then findOf is more flexible in what it accepts.

findOf l = ifoldOf l . const

 ifindOf :: IndexedGetter a c          -> (i -> c -> Bool) -> a -> Maybe (i, c)
 ifindOf :: IndexedFold a c            -> (i -> c -> Bool) -> a -> Maybe (i, c)
 ifindOf :: SimpleIndexedLens a c      -> (i -> c -> Bool) -> a -> Maybe (i, c)
 ifindOf :: SimpleIndexedTraversal a c -> (i -> c -> Bool) -> a -> Maybe (i, c)

ifoldrOf' :: IndexedGetting i (Dual (Endo (e -> e))) a c -> (i -> c -> e -> e) -> e -> a -> e

Strictly fold right over the elements of a structure with an index.

When you don't need access to the index then foldrOf' is more flexible in what it accepts.

foldrOf' l = ifoldrOf' l . const

 ifoldrOf' :: IndexedGetter i a c          -> (i -> c -> e -> e) -> e -> a -> e
 ifoldrOf' :: IndexedFold i a c            -> (i -> c -> e -> e) -> e -> a -> e
 ifoldrOf' :: SimpleIndexedLens i a c      -> (i -> c -> e -> e) -> e -> a -> e
 ifoldrOf' :: SimpleIndexedTraversal i a c -> (i -> c -> e -> e) -> e -> a -> e

ifoldlOf' :: IndexedGetting i (Endo (e -> e)) a c -> (i -> e -> c -> e) -> e -> a -> e

Fold over the elements of a structure with an index, associating to the left, but strictly.

When you don't need access to the index then foldlOf' is more flexible in what it accepts.

foldlOf' l = ifoldlOf' l . const

 ifoldlOf' :: IndexedGetter i a c            -> (i -> e -> c -> e) -> e -> a -> e
 ifoldlOf' :: IndexedFold i a c              -> (i -> e -> c -> e) -> e -> a -> e
 ifoldlOf' :: SimpleIndexedLens i a c        -> (i -> e -> c -> e) -> e -> a -> e
 ifoldlOf' :: SimpleIndexedTraversal i a c   -> (i -> e -> c -> e) -> e -> a -> e

ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (e -> m e))) a c -> (i -> c -> e -> m e) -> e -> a -> m e

Monadic fold right over the elements of a structure with an index.

When you don't need access to the index then foldrMOf is more flexible in what it accepts.

foldrMOf l = ifoldrMOf l . const

 ifoldrMOf :: Monad m => IndexedGetter i a c          -> (i -> c -> e -> m e) -> e -> a -> e
 ifoldrMOf :: Monad m => IndexedFold i a c            -> (i -> c -> e -> m e) -> e -> a -> e
 ifoldrMOf :: Monad m => SimpleIndexedLens i a c      -> (i -> c -> e -> m e) -> e -> a -> e
 ifoldrMOf :: Monad m => SimpleIndexedTraversal i a c -> (i -> c -> e -> m e) -> e -> a -> e

ifoldlMOf :: Monad m => IndexedGetting i (Endo (e -> m e)) a c -> (i -> e -> c -> m e) -> e -> a -> m e

Monadic fold over the elements of a structure with an index, associating to the left.

When you don't need access to the index then foldlMOf is more flexible in what it accepts.

foldlMOf l = ifoldlMOf l . const

 ifoldlOf' :: Monad m => IndexedGetter i a c            -> (i -> e -> c -> m e) -> e -> a -> e
 ifoldlOf' :: Monad m => IndexedFold i a c              -> (i -> e -> c -> m e) -> e -> a -> e
 ifoldlOf' :: Monad m => SimpleIndexedLens i a c        -> (i -> e -> c -> m e) -> e -> a -> e
 ifoldlOf' :: Monad m => SimpleIndexedTraversal i a c   -> (i -> e -> c -> m e) -> e -> a -> e

itoListOf :: IndexedGetting i [(i, c)] a c -> a -> [(i, c)]

Extract the key-value pairs from a structure.

When you don't need access to the indices in the result, then toListOf is more flexible in what it accepts.

toListOf l = map fst . itoListOf l

 itoListOf :: IndexedGetter i a c          -> a -> [(i,c)]
 itoListOf :: IndexedFold i a c            -> a -> [(i,c)]
 itoListOf :: SimpleIndexedLens i a c      -> a -> [(i,c)]
 itoListOf :: SimpleIndexedTraversal i a c -> a -> [(i,c)]

Building Indexed Folds

ifiltered :: (Gettable f, Applicative f, Indexed i k) => (i -> c -> Bool) -> Index i (c -> f c) (a -> f a) -> k (c -> f c) (a -> f a)

Obtain an IndexedFold by filtering a IndexedLens, IndexedGetter, IndexedFold or IndexedTraversal.

itakingWhile :: (Gettable f, Applicative f, Indexed i k) => (i -> c -> Bool) -> IndexedGetting i (Endo (f a)) a c -> k (c -> f c) (a -> f a)

Obtain an IndexedFold by taking elements from another IndexedFold, IndexedLens, IndexedGetter or IndexedTraversal while a predicate holds.

idroppingWhile :: (Gettable f, Applicative f, Indexed i k) => (i -> c -> Bool) -> IndexedGetting i (Endo (f a)) a c -> k (c -> f c) (a -> f a)

Obtain an IndexedFold by dropping elements from another IndexedFold, IndexedLens, IndexedGetter or IndexedTraversal while a predicate holds.