lens-2.5: Lenses, Folds and Traversals

Portabilityrank 2 types, MPTCs, TFs, flexible
Stabilityprovisional
MaintainerEdward Kmett <ekmett@gmail.com>
Safe HaskellSafe-Infered

Control.Lens.IndexedFold

Contents

Description

 

Synopsis

Indexed Folds

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

Every IndexedFold is a valid Fold.

Consuming Indexed Folds

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

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 -> eSource

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 -> eSource

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 -> BoolSource

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 -> BoolSource

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 ()Source

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 ()Source

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 ()Source

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 ()Source

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

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 = iconcatMapOf l . const
 iconcatMapOf = ifoldMapOf
 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)Source

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 = ifindOf 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 -> eSource

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 -> eSource

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 eSource

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 eSource

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)]Source

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)Source

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)Source

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)Source

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

Storing Indexed Folds

newtype ReifiedIndexedFold i a c Source

Useful for storage.

Constructors

ReifyIndexedFold