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)