Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m

lens	Control.Lens.Combinators

Fold an IndexedFold or IndexedTraversal by mapping indices and values to an arbitrary Monoid with access to the 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 s a     -> (i -> a -> m) -> s -> m
ifoldMapOf :: Monoid m => IndexedFold i s a       -> (i -> a -> m) -> s -> m
ifoldMapOf ::             IndexedLens' i s a      -> (i -> a -> m) -> s -> m
ifoldMapOf :: Monoid m => IndexedTraversal' i s a -> (i -> a -> m) -> s -> m

imap :: FunctorWithIndex i f => (i -> a -> b) -> f a -> f b

lens Control.Lens.Combinators

Map with access to the index.
imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)

lens Control.Lens.Combinators

Generalizes mapAccumL to add access to the index. imapAccumL accumulates state from left to right.
```
mapAccumL ≡ imapAccumL . const
```
imapAccumLOf :: Over (Indexed i) (State acc) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

lens Control.Lens.Combinators

Generalizes mapAccumL to an arbitrary IndexedTraversal with access to the index. imapAccumLOf accumulates state from left to right.
```
mapAccumLOf l ≡ imapAccumLOf l . const
```
```
imapAccumLOf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumLOf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
```
imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)

lens Control.Lens.Combinators

Generalizes mapAccumR to add access to the index. imapAccumR accumulates state from right to left.
```
mapAccumR ≡ imapAccumR . const
```
imapAccumROf :: Over (Indexed i) (Backwards (State acc)) s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)

lens Control.Lens.Combinators

Generalizes mapAccumR to an arbitrary IndexedTraversal with access to the index. imapAccumROf accumulates state from right to left.
```
mapAccumROf l ≡ imapAccumROf l . const
```
```
imapAccumROf :: IndexedLens i s t a b      -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
imapAccumROf :: IndexedTraversal i s t a b -> (i -> acc -> a -> (acc, b)) -> acc -> s -> (acc, t)
```
imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)

lens Control.Lens.Combinators

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access the index. When you don't need access to the index mapM is more liberal in what it can accept.
```
mapM ≡ imapM . const
```
imapMOf :: Over (Indexed i) (WrappedMonad m) s t a b -> (i -> a -> m b) -> s -> m t

lens Control.Lens.Combinators

Map each element of a structure targeted by a Lens to a monadic action, evaluate these actions from left to right, and collect the results, with access its position. When you don't need access to the index mapMOf is more liberal in what it can accept.
```
mapMOf l ≡ imapMOf l . const
```
```
imapMOf :: Monad m => IndexedLens       i s t a b -> (i -> a -> m b) -> s -> m t
imapMOf :: Monad m => IndexedTraversal  i s t a b -> (i -> a -> m b) -> s -> m t
imapMOf :: Bind  m => IndexedTraversal1 i s t a b -> (i -> a -> m b) -> s -> m t
```

imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()

lens	Control.Lens.Combinators

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 s a     -> (i -> a -> m r) -> s -> m ()
imapMOf_ :: Monad m => IndexedFold i s a       -> (i -> a -> m r) -> s -> m ()
imapMOf_ :: Monad m => IndexedLens' i s a      -> (i -> a -> m r) -> s -> m ()
imapMOf_ :: Monad m => IndexedTraversal' i s a -> (i -> a -> m r) -> s -> m ()

imapM_ :: (FoldableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m ()

lens Control.Lens.Combinators

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.
```
mapM_ ≡ imapM . const
```

Page 418 of many | Previous | Next