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

Stability | provisional |

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

Safe Haskell | Safe-Infered |

- type IndexedLens i a b c d = forall f k. (Indexed i k, Functor f) => k (c -> f d) (a -> f b)
- (%%@~) :: Overloaded (Index i) f a b c d -> (i -> c -> f d) -> a -> f b
- (<%@~) :: Overloaded (Index i) ((,) d) a b c d -> (i -> c -> d) -> a -> (d, b)
- (%%@=) :: MonadState a m => Overloaded (Index i) ((,) e) a a c d -> (i -> c -> (e, d)) -> m e
- (<%@=) :: MonadState a m => Overloaded (Index i) ((,) d) a a c d -> (i -> c -> d) -> m d
- type SimpleIndexedLens i a b = IndexedLens i a a b b

# Indexed Lenses

type IndexedLens i a b c d = forall f k. (Indexed i k, Functor f) => k (c -> f d) (a -> f b)Source

Every `IndexedLens`

is a valid `Lens`

and a valid `IndexedTraversal`

.

(%%@~) :: Overloaded (Index i) f a b c d -> (i -> c -> f d) -> a -> f bSource

Adjust the target of an `IndexedLens`

returning a supplementary result, or
adjust all of the targets of an `IndexedTraversal`

and return a monoidal summary
of the supplementary results and the answer.

(`%%@~`

) =`withIndex`

(%%@~) ::`Functor`

f =>`IndexedLens`

i a b c d -> (i -> c -> f d) -> a -> f b (%%@~) ::`Functor`

f =>`IndexedTraversal`

i a b c d -> (i -> c -> f d) -> a -> f b

In particular, it is often useful to think of this function as having one of these even more restrictive type signatures

(%%@~) ::`IndexedLens`

i a b c d -> (i -> c -> (e, d)) -> a -> (e, b) (%%@~) ::`Monoid`

e =>`IndexedTraversal`

i a b c d -> (i -> c -> (e, d)) -> a -> (e, b)

(<%@~) :: Overloaded (Index i) ((,) d) a b c d -> (i -> c -> d) -> a -> (d, b)Source

Adjust the target of an `IndexedLens`

returning the intermediate result, or
adjust all of the targets of an `IndexedTraversal`

and return a monoidal summary
along with the answer.

l`<%~`

f = l`<%@~`

`const`

f

When you do not need access to the index then (`<%~`

) is more liberal in what it can accept.

If you do not need the intermediate result, you can use (`%@~`

) or even (`%~`

).

(<%@~) ::`IndexedLens`

i a b c d -> (i -> c -> d) -> a -> (d, b) (<%@~) ::`Monoid`

d =>`IndexedTraversal`

i a b c d -> (i -> c -> d) -> a -> (d, b)

(%%@=) :: MonadState a m => Overloaded (Index i) ((,) e) a a c d -> (i -> c -> (e, d)) -> m eSource

Adjust the target of an `IndexedLens`

returning a supplementary result, or
adjust all of the targets of an `IndexedTraversal`

within the current state, and
return a monoidal summary of the supplementary results.

l`%%@=`

f =`state`

(l`%%@~`

f)

(%%@=) ::`MonadState`

a m`IndexedLens`

i a a c d -> (i -> c -> (e, d)) -> a -> m e (%%@=) :: (`MonadState`

a m,`Monoid`

e) =>`IndexedTraversal`

i a a c d -> (i -> c -> (e, d)) -> a -> m e

(<%@=) :: MonadState a m => Overloaded (Index i) ((,) d) a a c d -> (i -> c -> d) -> m dSource

Adjust the target of an `IndexedLens`

returning the intermediate result, or
adjust all of the targets of an `IndexedTraversal`

within the current state, and
return a monoidal summary of the intermediate results.

(<%@=) ::`MonadState`

a m`IndexedLens`

i a a c d -> (i -> c -> d) -> a -> m d (<%@=) :: (`MonadState`

a m,`Monoid`

e) =>`IndexedTraversal`

i a a c d -> (i -> c -> d) -> a -> m d

# Simple

type SimpleIndexedLens i a b = IndexedLens i a a b bSource

type`SimpleIndexedLens`

i =`Simple`

(`IndexedLens`

i)