Control.Lens.IndexedLens

Indexed Lenses

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

Every IndexedLens is a valid Lens and a valid IndexedTraversal.

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

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)

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 e

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 d

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 b

type SimpleIndexedLens i = Simple (IndexedLens i)