Portability | rank 2 types, MPTCs, TFs, flexible |
---|---|

Stability | provisional |

Maintainer | Edward Kmett <ekmett@gmail.com> |

Safe Haskell | Safe-Infered |

- type IndexedFold i a c = forall k f. (Indexed i k, Applicative f, Gettable f) => k (c -> f c) (a -> f a)
- ifoldMapOf :: IndexedGetting i m a c -> (i -> c -> m) -> a -> m
- ifoldrOf :: IndexedGetting i (Endo e) a c -> (i -> c -> e -> e) -> e -> a -> e
- ifoldlOf :: IndexedGetting i (Dual (Endo e)) a c -> (i -> e -> c -> e) -> e -> a -> e
- ianyOf :: IndexedGetting i Any a c -> (i -> c -> Bool) -> a -> Bool
- iallOf :: IndexedGetting i All a c -> (i -> c -> Bool) -> a -> Bool
- itraverseOf_ :: Functor f => IndexedGetting i (Traversed f) a c -> (i -> c -> f e) -> a -> f ()
- iforOf_ :: Functor f => IndexedGetting i (Traversed f) a c -> a -> (i -> c -> f e) -> f ()
- imapMOf_ :: Monad m => IndexedGetting i (Sequenced m) a c -> (i -> c -> m e) -> a -> m ()
- iforMOf_ :: Monad m => IndexedGetting i (Sequenced m) a c -> a -> (i -> c -> m e) -> m ()
- iconcatMapOf :: IndexedGetting i [e] a c -> (i -> c -> [e]) -> a -> [e]
- ifindOf :: IndexedGetting i (First (i, c)) 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
- ifoldlOf' :: IndexedGetting i (Endo (e -> e)) 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
- ifoldlMOf :: Monad m => IndexedGetting i (Endo (e -> m e)) a c -> (i -> e -> c -> m e) -> e -> a -> m e
- itoListOf :: IndexedGetting i [(i, c)] a c -> a -> [(i, c)]
- withIndicesOf :: Functor f => Overloaded (Index i) f a b c d -> LensLike f a b (i, c) (j, d)
- indicesOf :: Gettable f => Overloaded (Index i) f a b c c -> LensLike f a b i j
- 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)
- 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)
- 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)
- newtype ReifiedIndexedFold i a c = ReifyIndexedFold {
- reflectIndexedFold :: IndexedFold i a c

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

# Converting to Folds

withIndicesOf :: Functor f => Overloaded (Index i) f a b c d -> LensLike f a b (i, c) (j, d)Source

Transform an indexed fold into a fold of both the indices and the values.

`withIndices`

::`IndexedFold`

i a c ->`Fold`

a (i, c)`withIndices`

::`Simple`

`IndexedLens`

i a c ->`Getter`

a (i, c)`withIndices`

::`Simple`

`IndexedTraversal`

i a c ->`Fold`

a (i, c)

All `Fold`

operations are safe, and comply with the laws. However,

Passing this an `IndexedTraversal`

will still allow many
`Traversal`

combinators to type check on the result, but the result
can only be legally traversed by operations that do not edit the indices.

`withIndices`

::`IndexedTraversal`

i a b c d ->`Traversal`

a b (i, c) (j, d)

Change made to the indices will be discarded.

indicesOf :: Gettable f => Overloaded (Index i) f a b c c -> LensLike f a b i jSource

Transform an indexed fold into a fold of the indices.

`indices`

::`IndexedFold`

i a c ->`Fold`

a i`indices`

::`Simple`

`IndexedLens`

i a c ->`Getter`

a i`indices`

::`Simple`

`IndexedTraversal`

i a c ->`Fold`

a i

# 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

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