Control.Lens.Indexed

(The classes in here need to be defined together for DefaultSignatures to work.)

Indexing

class Conjoined p => Indexable i p where

This class permits overloading of function application for things that also admit a notion of a key or index.

Methods

indexed :: p a b -> i -> a -> b

Build a function from an indexed function.

Instances

i ~ j => Indexable i (Indexed j)

Defined in Control.Lens.Internal.Indexed

Methods

indexed :: Indexed j a b -> i -> a -> b

Indexable i ((->) :: Type -> Type -> Type)

Defined in Control.Lens.Internal.Indexed

Methods

indexed :: (a -> b) -> i -> a -> b

class (Choice p, Corepresentable p, Comonad (Corep p), Traversable (Corep p), Strong p, Representable p, Monad (Rep p), MonadFix (Rep p), Distributive (Rep p), Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p) => Conjoined p where

This is a Profunctor that is both Corepresentable by f and Representable by g such that f is left adjoint to g. From this you can derive a lot of structure due to the preservation of limits and colimits.

Minimal complete definition

Nothing

Methods

distrib :: Functor f => p a b -> p (f a) (f b)

Conjoined is strong enough to let us distribute every Conjoined Profunctor over every Haskell Functor. This is effectively a generalization of fmap.

conjoined :: (p ~ (->) => q (a -> b) r) -> q (p a b) r -> q (p a b) r

This permits us to make a decision at an outermost point about whether or not we use an index.

Ideally any use of this function should be done in such a way so that you compute the same answer, but this cannot be enforced at the type level.

Instances

Conjoined ReifiedGetter

Defined in Control.Lens.Reified

Methods

distrib :: Functor f => ReifiedGetter a b -> ReifiedGetter (f a) (f b)

conjoined :: ((ReifiedGetter ~ (->)) -> q (a -> b) r) -> q (ReifiedGetter a b) r -> q (ReifiedGetter a b) r

Conjoined (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b)

conjoined :: ((Indexed i ~ (->)) -> q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r

Conjoined ((->) :: Type -> Type -> Type)

Defined in Control.Lens.Internal.Indexed

Methods

distrib :: Functor f => (a -> b) -> f a -> f b

conjoined :: (((->) ~ (->)) -> q (a -> b) r) -> q (a -> b) r -> q (a -> b) r

newtype Indexed i a b

A function with access to a index. This constructor may be useful when you need to store an Indexable in a container to avoid ImpredicativeTypes.

index :: Indexed i a b -> i -> a -> b

Constructors

Indexed

Fields

• runIndexed :: i -> a -> b

Instances

i ~ j => Indexable i (Indexed j)

Defined in Control.Lens.Internal.Indexed

Methods

indexed :: Indexed j a b -> i -> a -> b

Arrow (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

arr :: (b -> c) -> Indexed i b c

first :: Indexed i b c -> Indexed i (b, d) (c, d)

second :: Indexed i b c -> Indexed i (d, b) (d, c)

(***) :: Indexed i b c -> Indexed i b' c' -> Indexed i (b, b') (c, c')

(&&&) :: Indexed i b c -> Indexed i b c' -> Indexed i b (c, c')

ArrowChoice (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

left :: Indexed i b c -> Indexed i (Either b d) (Either c d)

right :: Indexed i b c -> Indexed i (Either d b) (Either d c)

(+++) :: Indexed i b c -> Indexed i b' c' -> Indexed i (Either b b') (Either c c')

(|||) :: Indexed i b d -> Indexed i c d -> Indexed i (Either b c) d

ArrowApply (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

app :: Indexed i (Indexed i b c, b) c

ArrowLoop (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

loop :: Indexed i (b, d) (c, d) -> Indexed i b c

Profunctor (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

dimap :: (a -> b) -> (c -> d) -> Indexed i b c -> Indexed i a d

lmap :: (a -> b) -> Indexed i b c -> Indexed i a c

rmap :: (b -> c) -> Indexed i a b -> Indexed i a c

(#.) :: Coercible c b => q b c -> Indexed i a b -> Indexed i a c

(.#) :: Coercible b a => Indexed i b c -> q a b -> Indexed i a c

Representable (Indexed i)

Defined in Control.Lens.Internal.Indexed

Associated Types

type Rep (Indexed i) :: Type -> Type

Methods

tabulate :: (d -> Rep (Indexed i) c) -> Indexed i d c

Corepresentable (Indexed i)

Defined in Control.Lens.Internal.Indexed

Associated Types

type Corep (Indexed i) :: Type -> Type

Methods

cotabulate :: (Corep (Indexed i) d -> c) -> Indexed i d c

Choice (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

left' :: Indexed i a b -> Indexed i (Either a c) (Either b c)

right' :: Indexed i a b -> Indexed i (Either c a) (Either c b)

Closed (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

closed :: Indexed i a b -> Indexed i (x -> a) (x -> b)

Strong (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

first' :: Indexed i a b -> Indexed i (a, c) (b, c)

second' :: Indexed i a b -> Indexed i (c, a) (c, b)

Costrong (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

unfirst :: Indexed i (a, d) (b, d) -> Indexed i a b

unsecond :: Indexed i (d, a) (d, b) -> Indexed i a b

Conjoined (Indexed i)

Defined in Control.Lens.Internal.Indexed

Methods

distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b)

conjoined :: ((Indexed i ~ (->)) -> q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r

Bizarre (Indexed Int) Mafic

Defined in Control.Lens.Internal.Magma

Methods

bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t

Category (Indexed i :: Type -> Type -> Type)

Defined in Control.Lens.Internal.Indexed

Methods

id :: Indexed i a a

(.) :: Indexed i b c -> Indexed i a b -> Indexed i a c

Cosieve (Indexed i) ((,) i)

Defined in Control.Lens.Internal.Indexed

Methods

cosieve :: Indexed i a b -> (i, a) -> b

Sellable (Indexed i) (Molten i)

Defined in Control.Lens.Internal.Magma

Methods

sell :: Indexed i a (Molten i a b b)

Bizarre (Indexed i) (Molten i)

Defined in Control.Lens.Internal.Magma

Methods

bazaar :: Applicative f => Indexed i a (f b) -> Molten i a b t -> f t

Sieve (Indexed i) ((->) i :: Type -> Type)

Defined in Control.Lens.Internal.Indexed

Methods

sieve :: Indexed i a b -> a -> i -> b

Monad (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

(>>=) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b

(>>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b

return :: a0 -> Indexed i a a0

fail :: String -> Indexed i a a0

Functor (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

fmap :: (a0 -> b) -> Indexed i a a0 -> Indexed i a b

(<$) :: a0 -> Indexed i a b -> Indexed i a a0

MonadFix (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

mfix :: (a0 -> Indexed i a a0) -> Indexed i a a0

Applicative (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

pure :: a0 -> Indexed i a a0

(<*>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b

liftA2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c

(*>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b

(<*) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0

Apply (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

(<.>) :: Indexed i a (a0 -> b) -> Indexed i a a0 -> Indexed i a b

(.>) :: Indexed i a a0 -> Indexed i a b -> Indexed i a b

(<.) :: Indexed i a a0 -> Indexed i a b -> Indexed i a a0

liftF2 :: (a0 -> b -> c) -> Indexed i a a0 -> Indexed i a b -> Indexed i a c

Bind (Indexed i a)

Defined in Control.Lens.Internal.Indexed

Methods

(>>-) :: Indexed i a a0 -> (a0 -> Indexed i a b) -> Indexed i a b

join :: Indexed i a (Indexed i a a0) -> Indexed i a a0

type Rep (Indexed i)

Defined in Control.Lens.Internal.Indexed

type Rep (Indexed i) = ((->) i :: Type -> Type)

type Corep (Indexed i)

Defined in Control.Lens.Internal.Indexed

type Corep (Indexed i) = (,) i

(<.) :: Indexable i p => (Indexed i s t -> r) -> ((a -> b) -> s -> t) -> p a b -> r infixr 9

Compose an Indexed function with a non-indexed function.

Mnemonically, the < points to the indexing we want to preserve.

>>> let nestedMap = (fmap Map.fromList . Map.fromList) [(1, [(10, "one,ten"), (20, "one,twenty")]), (2, [(30, "two,thirty"), (40,"two,forty")])]
>>> nestedMap^..(itraversed<.itraversed).withIndex
[(1,"one,ten"),(1,"one,twenty"),(2,"two,thirty"),(2,"two,forty")]

(<.>) :: Indexable (i, j) p => (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> p a b -> r infixr 9

Composition of Indexed functions.

Mnemonically, the < and > points to the fact that we want to preserve the indices.

>>> let nestedMap = (fmap Map.fromList . Map.fromList) [(1, [(10, "one,ten"), (20, "one,twenty")]), (2, [(30, "two,thirty"), (40,"two,forty")])]
>>> nestedMap^..(itraversed<.>itraversed).withIndex
[((1,10),"one,ten"),((1,20),"one,twenty"),((2,30),"two,thirty"),((2,40),"two,forty")]

(.>) :: (st -> r) -> (kab -> st) -> kab -> r infixr 9

Compose a non-indexed function with an Indexed function.

Mnemonically, the > points to the indexing we want to preserve.

This is the same as (.).

f . g (and f .> g) gives you the index of g unless g is index-preserving, like a Prism, Iso or Equality, in which case it'll pass through the index of f.

>>> let nestedMap = (fmap Map.fromList . Map.fromList) [(1, [(10, "one,ten"), (20, "one,twenty")]), (2, [(30, "two,thirty"), (40,"two,forty")])]
>>> nestedMap^..(itraversed.>itraversed).withIndex
[(10,"one,ten"),(20,"one,twenty"),(30,"two,thirty"),(40,"two,forty")]

selfIndex :: Indexable a p => p a fb -> a -> fb

Use a value itself as its own index. This is essentially an indexed version of id.

Note: When used to modify the value, this can break the index requirements assumed by indices and similar, so this is only properly an IndexedGetter, but it can be used as more.

selfIndex :: IndexedGetter a a b

reindexed :: Indexable j p => (i -> j) -> (Indexed i a b -> r) -> p a b -> r

Remap the index.

icompose :: Indexable p c => (i -> j -> p) -> (Indexed i s t -> r) -> (Indexed j a b -> s -> t) -> c a b -> r

Composition of Indexed functions with a user supplied function for combining indices.

indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t

Transform a Traversal into an IndexedTraversal or a Fold into an IndexedFold, etc.

indexing :: Traversal s t a b -> IndexedTraversal Int s t a b
indexing :: Prism s t a b     -> IndexedTraversal Int s t a b
indexing :: Lens s t a b      -> IndexedLens Int  s t a b
indexing :: Iso s t a b       -> IndexedLens Int s t a b
indexing :: Fold s a          -> IndexedFold Int s a
indexing :: Getter s a        -> IndexedGetter Int s a

indexing :: Indexable Int p => LensLike (Indexing f) s t a b -> Over p f s t a b

indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t

Transform a Traversal into an IndexedTraversal or a Fold into an IndexedFold, etc.

This combinator is like indexing except that it handles large traversals and folds gracefully.

indexing64 :: Traversal s t a b -> IndexedTraversal Int64 s t a b
indexing64 :: Prism s t a b     -> IndexedTraversal Int64 s t a b
indexing64 :: Lens s t a b      -> IndexedLens Int64 s t a b
indexing64 :: Iso s t a b       -> IndexedLens Int64 s t a b
indexing64 :: Fold s a          -> IndexedFold Int64 s a
indexing64 :: Getter s a        -> IndexedGetter Int64 s a

indexing64 :: Indexable Int64 p => LensLike (Indexing64 f) s t a b -> Over p f s t a b

Indexed Functors

class Functor f => FunctorWithIndex i f | f -> i where

A Functor with an additional index.

Instances must satisfy a modified form of the Functor laws:

imap f . imap g ≡ imap (\i -> f i . g i)
imap (\_ a -> a) ≡ id

Minimal complete definition

Nothing

Methods

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

Map with access to the index.

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

Map with access to the index.

imapped :: IndexedSetter i (f a) (f b) a b

The IndexedSetter for a FunctorWithIndex.

If you don't need access to the index, then mapped is more flexible in what it accepts.

Instances

FunctorWithIndex Int []

The position in the list is available as the index.

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> [a] -> [b]

imapped :: IndexedSetter Int [a] [b] a b

FunctorWithIndex Int ZipList

Same instance as for [].

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> ZipList a -> ZipList b

imapped :: IndexedSetter Int (ZipList a) (ZipList b) a b

FunctorWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b

imapped :: IndexedSetter Int (NonEmpty a) (NonEmpty b) a b

FunctorWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> IntMap a -> IntMap b

imapped :: IndexedSetter Int (IntMap a) (IntMap b) a b

FunctorWithIndex Int Seq

The position in the Seq is available as the index.

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> Seq a -> Seq b

imapped :: IndexedSetter Int (Seq a) (Seq b) a b

FunctorWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

imap :: (Int -> a -> b) -> Vector a -> Vector b

imapped :: IndexedSetter Int (Vector a) (Vector b) a b

FunctorWithIndex Int Deque

Defined in Control.Lens.Internal.Deque

Methods

imap :: (Int -> a -> b) -> Deque a -> Deque b

imapped :: IndexedSetter Int (Deque a) (Deque b) a b

FunctorWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

imap :: (() -> a -> b) -> Maybe a -> Maybe b

imapped :: IndexedSetter () (Maybe a) (Maybe b) a b

FunctorWithIndex () Par1

Defined in Control.Lens.Indexed

Methods

imap :: (() -> a -> b) -> Par1 a -> Par1 b

imapped :: IndexedSetter () (Par1 a) (Par1 b) a b

FunctorWithIndex () Identity

Defined in Control.Lens.Indexed

Methods

imap :: (() -> a -> b) -> Identity a -> Identity b

imapped :: IndexedSetter () (Identity a) (Identity b) a b

Ix i => FunctorWithIndex i (Array i)

Defined in Control.Lens.Indexed

Methods

imap :: (i -> a -> b) -> Array i a -> Array i b

imapped :: IndexedSetter i (Array i a) (Array i b) a b

FunctorWithIndex i (Level i)

Defined in Control.Lens.Indexed

Methods

imap :: (i -> a -> b) -> Level i a -> Level i b

imapped :: IndexedSetter i (Level i a) (Level i b) a b

FunctorWithIndex k (HashMap k)

Defined in Control.Lens.Indexed

Methods

imap :: (k -> a -> b) -> HashMap k a -> HashMap k b

imapped :: IndexedSetter k (HashMap k a) (HashMap k b) a b

FunctorWithIndex k (Map k)

Defined in Control.Lens.Indexed

Methods

imap :: (k -> a -> b) -> Map k a -> Map k b

imapped :: IndexedSetter k (Map k a) (Map k b) a b

FunctorWithIndex k ((,) k)

Defined in Control.Lens.Indexed

Methods

imap :: (k -> a -> b) -> (k, a) -> (k, b)

imapped :: IndexedSetter k (k, a) (k, b) a b

FunctorWithIndex Void (V1 :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

imap :: (Void -> a -> b) -> V1 a -> V1 b

imapped :: IndexedSetter Void (V1 a) (V1 b) a b

FunctorWithIndex Void (U1 :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

imap :: (Void -> a -> b) -> U1 a -> U1 b

imapped :: IndexedSetter Void (U1 a) (U1 b) a b

FunctorWithIndex Void (Proxy :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

imap :: (Void -> a -> b) -> Proxy a -> Proxy b

imapped :: IndexedSetter Void (Proxy a) (Proxy b) a b

FunctorWithIndex () (Tagged a)

Defined in Control.Lens.Indexed

Methods

imap :: (() -> a0 -> b) -> Tagged a a0 -> Tagged a b

imapped :: IndexedSetter () (Tagged a a0) (Tagged a b) a0 b

FunctorWithIndex i f => FunctorWithIndex i (Rec1 f)

Defined in Control.Lens.Indexed

Methods

imap :: (i -> a -> b) -> Rec1 f a -> Rec1 f b

imapped :: IndexedSetter i (Rec1 f a) (Rec1 f b) a b

FunctorWithIndex i m => FunctorWithIndex i (IdentityT m)

Defined in Control.Lens.Indexed

Methods

imap :: (i -> a -> b) -> IdentityT m a -> IdentityT m b

imapped :: IndexedSetter i (IdentityT m a) (IdentityT m b) a b

FunctorWithIndex i f => FunctorWithIndex i (Reverse f)

Defined in Control.Lens.Indexed

Methods

imap :: (i -> a -> b) -> Reverse f a -> Reverse f b

imapped :: IndexedSetter i (Reverse f a) (Reverse f b) a b

FunctorWithIndex i f => FunctorWithIndex i (Backwards f)

Defined in Control.Lens.Indexed

Methods

imap :: (i -> a -> b) -> Backwards f a -> Backwards f b

imapped :: IndexedSetter i (Backwards f a) (Backwards f b) a b

FunctorWithIndex Void (Const e :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

imap :: (Void -> a -> b) -> Const e a -> Const e b

imapped :: IndexedSetter Void (Const e a) (Const e b) a b

FunctorWithIndex Void (Constant e :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

imap :: (Void -> a -> b) -> Constant e a -> Constant e b

imapped :: IndexedSetter Void (Constant e a) (Constant e b) a b

FunctorWithIndex i (Magma i t b)

Defined in Control.Lens.Indexed

Methods

imap :: (i -> a -> b0) -> Magma i t b a -> Magma i t b b0

imapped :: IndexedSetter i (Magma i t b a) (Magma i t b b0) a b0

FunctorWithIndex r ((->) r :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

imap :: (r -> a -> b) -> (r -> a) -> r -> b

imapped :: IndexedSetter r (r -> a) (r -> b) a b

FunctorWithIndex Void (K1 i c :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

imap :: (Void -> a -> b) -> K1 i c a -> K1 i c b

imapped :: IndexedSetter Void (K1 i c a) (K1 i c b) a b

FunctorWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

imap :: ([Int] -> a -> b) -> Tree a -> Tree b

imapped :: IndexedSetter [Int] (Tree a) (Tree b) a b

FunctorWithIndex i f => FunctorWithIndex [i] (Cofree f)

Defined in Control.Lens.Indexed

Methods

imap :: ([i] -> a -> b) -> Cofree f a -> Cofree f b

imapped :: IndexedSetter [i] (Cofree f a) (Cofree f b) a b

FunctorWithIndex i f => FunctorWithIndex [i] (Free f)

Defined in Control.Lens.Indexed

Methods

imap :: ([i] -> a -> b) -> Free f a -> Free f b

imapped :: IndexedSetter [i] (Free f a) (Free f b) a b

FunctorWithIndex i w => FunctorWithIndex (s, i) (TracedT s w)

Defined in Control.Lens.Indexed

Methods

imap :: ((s, i) -> a -> b) -> TracedT s w a -> TracedT s w b

imapped :: IndexedSetter (s, i) (TracedT s w a) (TracedT s w b) a b

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :+: g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> (f :+: g) a -> (f :+: g) b

imapped :: IndexedSetter (Either i j) ((f :+: g) a) ((f :+: g) b) a b

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (f :*: g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> (f :*: g) a -> (f :*: g) b

imapped :: IndexedSetter (Either i j) ((f :*: g) a) ((f :*: g) b) a b

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Product f g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> Product f g a -> Product f g b

imapped :: IndexedSetter (Either i j) (Product f g a) (Product f g b) a b

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Sum f g)

Defined in Control.Lens.Indexed

Methods

imap :: (Either i j -> a -> b) -> Sum f g a -> Sum f g b

imapped :: IndexedSetter (Either i j) (Sum f g a) (Sum f g b) a b

FunctorWithIndex i m => FunctorWithIndex (e, i) (ReaderT e m)

Defined in Control.Lens.Indexed

Methods

imap :: ((e, i) -> a -> b) -> ReaderT e m a -> ReaderT e m b

imapped :: IndexedSetter (e, i) (ReaderT e m a) (ReaderT e m b) a b

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (f :.: g)

Defined in Control.Lens.Indexed

Methods

imap :: ((i, j) -> a -> b) -> (f :.: g) a -> (f :.: g) b

imapped :: IndexedSetter (i, j) ((f :.: g) a) ((f :.: g) b) a b

(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (Compose f g)

Defined in Control.Lens.Indexed

Methods

imap :: ((i, j) -> a -> b) -> Compose f g a -> Compose f g b

imapped :: IndexedSetter (i, j) (Compose f g a) (Compose f g b) a b

Indexed Foldables

class Foldable f => FoldableWithIndex i f | f -> i where

A container that supports folding with an additional index.

Minimal complete definition

Nothing

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> f a -> m

Fold a container by mapping value to an arbitrary Monoid with access to the index i.

When you don't need access to the index then foldMap is more flexible in what it accepts.

foldMap ≡ ifoldMap . const

ifoldMap :: (TraversableWithIndex i f, Monoid m) => (i -> a -> m) -> f a -> m

Fold a container by mapping value to an arbitrary Monoid with access to the index i.

When you don't need access to the index then foldMap is more flexible in what it accepts.

foldMap ≡ ifoldMap . const

ifolded :: IndexedFold i (f a) a

The IndexedFold of a FoldableWithIndex container.

ifolded . asIndex is a fold over the keys of a FoldableWithIndex.

>>> Data.Map.fromList [(2, "hello"), (1, "world")]^..ifolded.asIndex
[1,2]

ifoldr :: (i -> a -> b -> b) -> b -> f a -> b

Right-associative fold of an indexed container with access to the index i.

When you don't need access to the index then foldr is more flexible in what it accepts.

foldr ≡ ifoldr . const

ifoldl :: (i -> b -> a -> b) -> b -> f a -> b

Left-associative fold of an indexed container with access to the index i.

When you don't need access to the index then foldl is more flexible in what it accepts.

foldl ≡ ifoldl . const

ifoldr' :: (i -> a -> b -> b) -> b -> f a -> b

Strictly fold right over the elements of a structure with access to the index i.

When you don't need access to the index then Foldable is more flexible in what it accepts.

Foldable ≡ ifoldr' . const

ifoldl' :: (i -> b -> a -> b) -> b -> f a -> b

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

Instances

FoldableWithIndex Int []

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m

ifolded :: IndexedFold Int [a] a

ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b

ifoldl :: (Int -> b -> a -> b) -> b -> [a] -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> [a] -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> [a] -> b

FoldableWithIndex Int ZipList

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> ZipList a -> m

ifolded :: IndexedFold Int (ZipList a) a

ifoldr :: (Int -> a -> b -> b) -> b -> ZipList a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> ZipList a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> ZipList a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> ZipList a -> b

FoldableWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m

ifolded :: IndexedFold Int (NonEmpty a) a

ifoldr :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b

FoldableWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m

ifolded :: IndexedFold Int (IntMap a) a

ifoldr :: (Int -> a -> b -> b) -> b -> IntMap a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> IntMap a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> IntMap a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> IntMap a -> b

FoldableWithIndex Int Seq

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m

ifolded :: IndexedFold Int (Seq a) a

ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b

FoldableWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Vector a -> m

ifolded :: IndexedFold Int (Vector a) a

ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> Vector a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> Vector a -> b

FoldableWithIndex Int Deque

Defined in Control.Lens.Internal.Deque

Methods

ifoldMap :: Monoid m => (Int -> a -> m) -> Deque a -> m

ifolded :: IndexedFold Int (Deque a) a

ifoldr :: (Int -> a -> b -> b) -> b -> Deque a -> b

ifoldl :: (Int -> b -> a -> b) -> b -> Deque a -> b

ifoldr' :: (Int -> a -> b -> b) -> b -> Deque a -> b

ifoldl' :: (Int -> b -> a -> b) -> b -> Deque a -> b

FoldableWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (() -> a -> m) -> Maybe a -> m

ifolded :: IndexedFold () (Maybe a) a

ifoldr :: (() -> a -> b -> b) -> b -> Maybe a -> b

ifoldl :: (() -> b -> a -> b) -> b -> Maybe a -> b

ifoldr' :: (() -> a -> b -> b) -> b -> Maybe a -> b

ifoldl' :: (() -> b -> a -> b) -> b -> Maybe a -> b

FoldableWithIndex () Par1

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (() -> a -> m) -> Par1 a -> m

ifolded :: IndexedFold () (Par1 a) a

ifoldr :: (() -> a -> b -> b) -> b -> Par1 a -> b

ifoldl :: (() -> b -> a -> b) -> b -> Par1 a -> b

ifoldr' :: (() -> a -> b -> b) -> b -> Par1 a -> b

ifoldl' :: (() -> b -> a -> b) -> b -> Par1 a -> b

FoldableWithIndex () Identity

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (() -> a -> m) -> Identity a -> m

ifolded :: IndexedFold () (Identity a) a

ifoldr :: (() -> a -> b -> b) -> b -> Identity a -> b

ifoldl :: (() -> b -> a -> b) -> b -> Identity a -> b

ifoldr' :: (() -> a -> b -> b) -> b -> Identity a -> b

ifoldl' :: (() -> b -> a -> b) -> b -> Identity a -> b

Ix i => FoldableWithIndex i (Array i)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> Array i a -> m

ifolded :: IndexedFold i (Array i a) a

ifoldr :: (i -> a -> b -> b) -> b -> Array i a -> b

ifoldl :: (i -> b -> a -> b) -> b -> Array i a -> b

ifoldr' :: (i -> a -> b -> b) -> b -> Array i a -> b

ifoldl' :: (i -> b -> a -> b) -> b -> Array i a -> b

FoldableWithIndex i (Level i)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> Level i a -> m

ifolded :: IndexedFold i (Level i a) a

ifoldr :: (i -> a -> b -> b) -> b -> Level i a -> b

ifoldl :: (i -> b -> a -> b) -> b -> Level i a -> b

ifoldr' :: (i -> a -> b -> b) -> b -> Level i a -> b

ifoldl' :: (i -> b -> a -> b) -> b -> Level i a -> b

FoldableWithIndex k (HashMap k)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (k -> a -> m) -> HashMap k a -> m

ifolded :: IndexedFold k (HashMap k a) a

ifoldr :: (k -> a -> b -> b) -> b -> HashMap k a -> b

ifoldl :: (k -> b -> a -> b) -> b -> HashMap k a -> b

ifoldr' :: (k -> a -> b -> b) -> b -> HashMap k a -> b

ifoldl' :: (k -> b -> a -> b) -> b -> HashMap k a -> b

FoldableWithIndex k (Map k)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (k -> a -> m) -> Map k a -> m

ifolded :: IndexedFold k (Map k a) a

ifoldr :: (k -> a -> b -> b) -> b -> Map k a -> b

ifoldl :: (k -> b -> a -> b) -> b -> Map k a -> b

ifoldr' :: (k -> a -> b -> b) -> b -> Map k a -> b

ifoldl' :: (k -> b -> a -> b) -> b -> Map k a -> b

FoldableWithIndex k ((,) k)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (k -> a -> m) -> (k, a) -> m

ifolded :: IndexedFold k (k, a) a

ifoldr :: (k -> a -> b -> b) -> b -> (k, a) -> b

ifoldl :: (k -> b -> a -> b) -> b -> (k, a) -> b

ifoldr' :: (k -> a -> b -> b) -> b -> (k, a) -> b

ifoldl' :: (k -> b -> a -> b) -> b -> (k, a) -> b

FoldableWithIndex Void (V1 :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Void -> a -> m) -> V1 a -> m

ifolded :: IndexedFold Void (V1 a) a

ifoldr :: (Void -> a -> b -> b) -> b -> V1 a -> b

ifoldl :: (Void -> b -> a -> b) -> b -> V1 a -> b

ifoldr' :: (Void -> a -> b -> b) -> b -> V1 a -> b

ifoldl' :: (Void -> b -> a -> b) -> b -> V1 a -> b

FoldableWithIndex Void (U1 :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Void -> a -> m) -> U1 a -> m

ifolded :: IndexedFold Void (U1 a) a

ifoldr :: (Void -> a -> b -> b) -> b -> U1 a -> b

ifoldl :: (Void -> b -> a -> b) -> b -> U1 a -> b

ifoldr' :: (Void -> a -> b -> b) -> b -> U1 a -> b

ifoldl' :: (Void -> b -> a -> b) -> b -> U1 a -> b

FoldableWithIndex Void (Proxy :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Void -> a -> m) -> Proxy a -> m

ifolded :: IndexedFold Void (Proxy a) a

ifoldr :: (Void -> a -> b -> b) -> b -> Proxy a -> b

ifoldl :: (Void -> b -> a -> b) -> b -> Proxy a -> b

ifoldr' :: (Void -> a -> b -> b) -> b -> Proxy a -> b

ifoldl' :: (Void -> b -> a -> b) -> b -> Proxy a -> b

FoldableWithIndex () (Tagged a)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (() -> a0 -> m) -> Tagged a a0 -> m

ifolded :: IndexedFold () (Tagged a a0) a0

ifoldr :: (() -> a0 -> b -> b) -> b -> Tagged a a0 -> b

ifoldl :: (() -> b -> a0 -> b) -> b -> Tagged a a0 -> b

ifoldr' :: (() -> a0 -> b -> b) -> b -> Tagged a a0 -> b

ifoldl' :: (() -> b -> a0 -> b) -> b -> Tagged a a0 -> b

FoldableWithIndex i f => FoldableWithIndex i (Rec1 f)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> Rec1 f a -> m

ifolded :: IndexedFold i (Rec1 f a) a

ifoldr :: (i -> a -> b -> b) -> b -> Rec1 f a -> b

ifoldl :: (i -> b -> a -> b) -> b -> Rec1 f a -> b

ifoldr' :: (i -> a -> b -> b) -> b -> Rec1 f a -> b

ifoldl' :: (i -> b -> a -> b) -> b -> Rec1 f a -> b

FoldableWithIndex i m => FoldableWithIndex i (IdentityT m)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m0 => (i -> a -> m0) -> IdentityT m a -> m0

ifolded :: IndexedFold i (IdentityT m a) a

ifoldr :: (i -> a -> b -> b) -> b -> IdentityT m a -> b

ifoldl :: (i -> b -> a -> b) -> b -> IdentityT m a -> b

ifoldr' :: (i -> a -> b -> b) -> b -> IdentityT m a -> b

ifoldl' :: (i -> b -> a -> b) -> b -> IdentityT m a -> b

FoldableWithIndex i f => FoldableWithIndex i (Reverse f)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> Reverse f a -> m

ifolded :: IndexedFold i (Reverse f a) a

ifoldr :: (i -> a -> b -> b) -> b -> Reverse f a -> b

ifoldl :: (i -> b -> a -> b) -> b -> Reverse f a -> b

ifoldr' :: (i -> a -> b -> b) -> b -> Reverse f a -> b

ifoldl' :: (i -> b -> a -> b) -> b -> Reverse f a -> b

FoldableWithIndex i f => FoldableWithIndex i (Backwards f)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> Backwards f a -> m

ifolded :: IndexedFold i (Backwards f a) a

ifoldr :: (i -> a -> b -> b) -> b -> Backwards f a -> b

ifoldl :: (i -> b -> a -> b) -> b -> Backwards f a -> b

ifoldr' :: (i -> a -> b -> b) -> b -> Backwards f a -> b

ifoldl' :: (i -> b -> a -> b) -> b -> Backwards f a -> b

FoldableWithIndex Void (Const e :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Void -> a -> m) -> Const e a -> m

ifolded :: IndexedFold Void (Const e a) a

ifoldr :: (Void -> a -> b -> b) -> b -> Const e a -> b

ifoldl :: (Void -> b -> a -> b) -> b -> Const e a -> b

ifoldr' :: (Void -> a -> b -> b) -> b -> Const e a -> b

ifoldl' :: (Void -> b -> a -> b) -> b -> Const e a -> b

FoldableWithIndex Void (Constant e :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Void -> a -> m) -> Constant e a -> m

ifolded :: IndexedFold Void (Constant e a) a

ifoldr :: (Void -> a -> b -> b) -> b -> Constant e a -> b

ifoldl :: (Void -> b -> a -> b) -> b -> Constant e a -> b

ifoldr' :: (Void -> a -> b -> b) -> b -> Constant e a -> b

ifoldl' :: (Void -> b -> a -> b) -> b -> Constant e a -> b

FoldableWithIndex i (Magma i t b)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (i -> a -> m) -> Magma i t b a -> m

ifolded :: IndexedFold i (Magma i t b a) a

ifoldr :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0

ifoldl :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0

ifoldr' :: (i -> a -> b0 -> b0) -> b0 -> Magma i t b a -> b0

ifoldl' :: (i -> b0 -> a -> b0) -> b0 -> Magma i t b a -> b0

FoldableWithIndex Void (K1 i c :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Void -> a -> m) -> K1 i c a -> m

ifolded :: IndexedFold Void (K1 i c a) a

ifoldr :: (Void -> a -> b -> b) -> b -> K1 i c a -> b

ifoldl :: (Void -> b -> a -> b) -> b -> K1 i c a -> b

ifoldr' :: (Void -> a -> b -> b) -> b -> K1 i c a -> b

ifoldl' :: (Void -> b -> a -> b) -> b -> K1 i c a -> b

FoldableWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m

ifolded :: IndexedFold [Int] (Tree a) a

ifoldr :: ([Int] -> a -> b -> b) -> b -> Tree a -> b

ifoldl :: ([Int] -> b -> a -> b) -> b -> Tree a -> b

ifoldr' :: ([Int] -> a -> b -> b) -> b -> Tree a -> b

ifoldl' :: ([Int] -> b -> a -> b) -> b -> Tree a -> b

FoldableWithIndex i f => FoldableWithIndex [i] (Cofree f)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => ([i] -> a -> m) -> Cofree f a -> m

ifolded :: IndexedFold [i] (Cofree f a) a

ifoldr :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b

ifoldl :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b

ifoldr' :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b

ifoldl' :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b

FoldableWithIndex i f => FoldableWithIndex [i] (Free f)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => ([i] -> a -> m) -> Free f a -> m

ifolded :: IndexedFold [i] (Free f a) a

ifoldr :: ([i] -> a -> b -> b) -> b -> Free f a -> b

ifoldl :: ([i] -> b -> a -> b) -> b -> Free f a -> b

ifoldr' :: ([i] -> a -> b -> b) -> b -> Free f a -> b

ifoldl' :: ([i] -> b -> a -> b) -> b -> Free f a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :+: g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :+: g) a -> m

ifolded :: IndexedFold (Either i j) ((f :+: g) a) a

ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :+: g) a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :+: g) a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (f :*: g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> (f :*: g) a -> m

ifolded :: IndexedFold (Either i j) ((f :*: g) a) a

ifoldr :: (Either i j -> a -> b -> b) -> b -> (f :*: g) a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> (f :*: g) a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> (f :*: g) a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> (f :*: g) a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Product f g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> Product f g a -> m

ifolded :: IndexedFold (Either i j) (Product f g a) a

ifoldr :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Sum f g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => (Either i j -> a -> m) -> Sum f g a -> m

ifolded :: IndexedFold (Either i j) (Sum f g a) a

ifoldr :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b

ifoldl :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b

ifoldr' :: (Either i j -> a -> b -> b) -> b -> Sum f g a -> b

ifoldl' :: (Either i j -> b -> a -> b) -> b -> Sum f g a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (f :.: g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => ((i, j) -> a -> m) -> (f :.: g) a -> m

ifolded :: IndexedFold (i, j) ((f :.: g) a) a

ifoldr :: ((i, j) -> a -> b -> b) -> b -> (f :.: g) a -> b

ifoldl :: ((i, j) -> b -> a -> b) -> b -> (f :.: g) a -> b

ifoldr' :: ((i, j) -> a -> b -> b) -> b -> (f :.: g) a -> b

ifoldl' :: ((i, j) -> b -> a -> b) -> b -> (f :.: g) a -> b

(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (Compose f g)

Defined in Control.Lens.Indexed

Methods

ifoldMap :: Monoid m => ((i, j) -> a -> m) -> Compose f g a -> m

ifolded :: IndexedFold (i, j) (Compose f g a) a

ifoldr :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b

ifoldl :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b

ifoldr' :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b

ifoldl' :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b

Indexed Foldable Combinators

iany :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool

Return whether or not any element in a container satisfies a predicate, with access to the index i.

When you don't need access to the index then any is more flexible in what it accepts.

any ≡ iany . const

iall :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool

Return whether or not all elements in a container satisfy a predicate, with access to the index i.

When you don't need access to the index then all is more flexible in what it accepts.

all ≡ iall . const

inone :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Bool

Return whether or not none of the elements in a container satisfy a predicate, with access to the index i.

When you don't need access to the index then none is more flexible in what it accepts.

none ≡ inone . const
inone f ≡ not . iany f

none :: Foldable f => (a -> Bool) -> f a -> Bool

Determines whether no elements of the structure satisfy the predicate.

none f ≡ not . any f

itraverse_ :: (FoldableWithIndex i t, Applicative f) => (i -> a -> f b) -> t a -> f ()

Traverse elements with access to the index i, discarding the results.

When you don't need access to the index then traverse_ is more flexible in what it accepts.

traverse_ l = itraverse . const

ifor_ :: (FoldableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f ()

Traverse elements with access to the index i, discarding the results (with the arguments flipped).

ifor_ ≡ flip itraverse_

When you don't need access to the index then for_ is more flexible in what it accepts.

for_ a ≡ ifor_ a . const

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

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

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

Run monadic actions for each target of an IndexedFold or IndexedTraversal with access to the index, discarding the results (with the arguments flipped).

iforM_ ≡ flip imapM_

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

iconcatMap :: FoldableWithIndex i f => (i -> a -> [b]) -> f a -> [b]

Concatenate the results of a function of the elements of an indexed container with access to the index.

When you don't need access to the index then concatMap is more flexible in what it accepts.

concatMap ≡ iconcatMap . const
iconcatMap ≡ ifoldMap

ifind :: FoldableWithIndex i f => (i -> a -> Bool) -> f a -> Maybe (i, a)

Searches a container with a predicate that is also supplied the index, returning 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 find is more flexible in what it accepts.

find ≡ ifind . const

ifoldrM :: (FoldableWithIndex i f, Monad m) => (i -> a -> b -> m b) -> b -> f a -> m b

Monadic fold right over the elements of a structure with an index.

When you don't need access to the index then foldrM is more flexible in what it accepts.

foldrM ≡ ifoldrM . const

ifoldlM :: (FoldableWithIndex i f, Monad m) => (i -> b -> a -> m b) -> b -> f a -> m b

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 foldlM is more flexible in what it accepts.

foldlM ≡ ifoldlM . const

itoList :: FoldableWithIndex i f => f a -> [(i, a)]

Extract the key-value pairs from a structure.

When you don't need access to the indices in the result, then toList is more flexible in what it accepts.

toList ≡ map snd . itoList

Converting to Folds

withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)

Fold a container with indices returning both the indices and the values.

The result is only valid to compose in a Traversal, if you don't edit the index as edits to the index have no effect.

>>> [10, 20, 30] ^.. ifolded . withIndex
[(0,10),(1,20),(2,30)]

>>> [10, 20, 30] ^.. ifolded . withIndex . alongside negated (re _Show)
[(0,"10"),(-1,"20"),(-2,"30")]

asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)

When composed with an IndexedFold or IndexedTraversal this yields an (Indexed) Fold of the indices.

Restricting by Index

indices :: (Indexable i p, Applicative f) => (i -> Bool) -> Optical' p (Indexed i) f a a

This allows you to filter an IndexedFold, IndexedGetter, IndexedTraversal or IndexedLens based on a predicate on the indices.

>>> ["hello","the","world","!!!"]^..traversed.indices even
["hello","world"]

>>> over (traversed.indices (>0)) Prelude.reverse $ ["He","was","stressed","o_O"]
["He","saw","desserts","O_o"]

index :: (Indexable i p, Eq i, Applicative f) => i -> Optical' p (Indexed i) f a a

This allows you to filter an IndexedFold, IndexedGetter, IndexedTraversal or IndexedLens based on an index.

>>> ["hello","the","world","!!!"]^?traversed.index 2
Just "world"

Indexed Traversables

class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i t | t -> i where

A Traversable with an additional index.

An instance must satisfy a (modified) form of the Traversable laws:

itraverse (const Identity) ≡ Identity
fmap (itraverse f) . itraverse g ≡ getCompose . itraverse (\i -> Compose . fmap (f i) . g i)

Minimal complete definition

Nothing

Methods

itraverse :: Applicative f => (i -> a -> f b) -> t a -> f (t b)

Traverse an indexed container.

itraverse ≡ itraverseOf itraversed

itraverse :: (i ~ Int, Applicative f) => (i -> a -> f b) -> t a -> f (t b)

Traverse an indexed container.

itraverse ≡ itraverseOf itraversed

itraversed :: IndexedTraversal i (t a) (t b) a b

The IndexedTraversal of a TraversableWithIndex container.

Instances

TraversableWithIndex Int []

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b]

itraversed :: IndexedTraversal Int [a] [b] a b

TraversableWithIndex Int ZipList

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> ZipList a -> f (ZipList b)

itraversed :: IndexedTraversal Int (ZipList a) (ZipList b) a b

TraversableWithIndex Int NonEmpty

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b)

itraversed :: IndexedTraversal Int (NonEmpty a) (NonEmpty b) a b

TraversableWithIndex Int IntMap

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b)

itraversed :: IndexedTraversal Int (IntMap a) (IntMap b) a b

TraversableWithIndex Int Seq

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b)

itraversed :: IndexedTraversal Int (Seq a) (Seq b) a b

TraversableWithIndex Int Vector

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Vector a -> f (Vector b)

itraversed :: IndexedTraversal Int (Vector a) (Vector b) a b

TraversableWithIndex Int Deque

Defined in Control.Lens.Internal.Deque

Methods

itraverse :: Applicative f => (Int -> a -> f b) -> Deque a -> f (Deque b)

itraversed :: IndexedTraversal Int (Deque a) (Deque b) a b

TraversableWithIndex () Maybe

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (() -> a -> f b) -> Maybe a -> f (Maybe b)

itraversed :: IndexedTraversal () (Maybe a) (Maybe b) a b

TraversableWithIndex () Par1

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (() -> a -> f b) -> Par1 a -> f (Par1 b)

itraversed :: IndexedTraversal () (Par1 a) (Par1 b) a b

TraversableWithIndex () Identity

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (() -> a -> f b) -> Identity a -> f (Identity b)

itraversed :: IndexedTraversal () (Identity a) (Identity b) a b

Ix i => TraversableWithIndex i (Array i)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (i -> a -> f b) -> Array i a -> f (Array i b)

itraversed :: IndexedTraversal i (Array i a) (Array i b) a b

TraversableWithIndex i (Level i)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (i -> a -> f b) -> Level i a -> f (Level i b)

itraversed :: IndexedTraversal i (Level i a) (Level i b) a b

TraversableWithIndex k (HashMap k)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (k -> a -> f b) -> HashMap k a -> f (HashMap k b)

itraversed :: IndexedTraversal k (HashMap k a) (HashMap k b) a b

TraversableWithIndex k (Map k)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (k -> a -> f b) -> Map k a -> f (Map k b)

itraversed :: IndexedTraversal k (Map k a) (Map k b) a b

TraversableWithIndex k ((,) k)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (k -> a -> f b) -> (k, a) -> f (k, b)

itraversed :: IndexedTraversal k (k, a) (k, b) a b

TraversableWithIndex Void (V1 :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Void -> a -> f b) -> V1 a -> f (V1 b)

itraversed :: IndexedTraversal Void (V1 a) (V1 b) a b

TraversableWithIndex Void (U1 :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Void -> a -> f b) -> U1 a -> f (U1 b)

itraversed :: IndexedTraversal Void (U1 a) (U1 b) a b

TraversableWithIndex Void (Proxy :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Void -> a -> f b) -> Proxy a -> f (Proxy b)

itraversed :: IndexedTraversal Void (Proxy a) (Proxy b) a b

TraversableWithIndex () (Tagged a)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (() -> a0 -> f b) -> Tagged a a0 -> f (Tagged a b)

itraversed :: IndexedTraversal () (Tagged a a0) (Tagged a b) a0 b

TraversableWithIndex i f => TraversableWithIndex i (Rec1 f)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (i -> a -> f0 b) -> Rec1 f a -> f0 (Rec1 f b)

itraversed :: IndexedTraversal i (Rec1 f a) (Rec1 f b) a b

TraversableWithIndex i m => TraversableWithIndex i (IdentityT m)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (i -> a -> f b) -> IdentityT m a -> f (IdentityT m b)

itraversed :: IndexedTraversal i (IdentityT m a) (IdentityT m b) a b

TraversableWithIndex i f => TraversableWithIndex i (Reverse f)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (i -> a -> f0 b) -> Reverse f a -> f0 (Reverse f b)

itraversed :: IndexedTraversal i (Reverse f a) (Reverse f b) a b

TraversableWithIndex i f => TraversableWithIndex i (Backwards f)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (i -> a -> f0 b) -> Backwards f a -> f0 (Backwards f b)

itraversed :: IndexedTraversal i (Backwards f a) (Backwards f b) a b

TraversableWithIndex Void (Const e :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Void -> a -> f b) -> Const e a -> f (Const e b)

itraversed :: IndexedTraversal Void (Const e a) (Const e b) a b

TraversableWithIndex Void (Constant e :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Void -> a -> f b) -> Constant e a -> f (Constant e b)

itraversed :: IndexedTraversal Void (Constant e a) (Constant e b) a b

TraversableWithIndex i (Magma i t b)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (i -> a -> f b0) -> Magma i t b a -> f (Magma i t b b0)

itraversed :: IndexedTraversal i (Magma i t b a) (Magma i t b b0) a b0

TraversableWithIndex Void (K1 i c :: Type -> Type)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => (Void -> a -> f b) -> K1 i c a -> f (K1 i c b)

itraversed :: IndexedTraversal Void (K1 i c a) (K1 i c b) a b

TraversableWithIndex [Int] Tree

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b)

itraversed :: IndexedTraversal [Int] (Tree a) (Tree b) a b

TraversableWithIndex i f => TraversableWithIndex [i] (Cofree f)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => ([i] -> a -> f0 b) -> Cofree f a -> f0 (Cofree f b)

itraversed :: IndexedTraversal [i] (Cofree f a) (Cofree f b) a b

TraversableWithIndex i f => TraversableWithIndex [i] (Free f)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => ([i] -> a -> f0 b) -> Free f a -> f0 (Free f b)

itraversed :: IndexedTraversal [i] (Free f a) (Free f b) a b

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :+: g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :+: g) a -> f0 ((f :+: g) b)

itraversed :: IndexedTraversal (Either i j) ((f :+: g) a) ((f :+: g) b) a b

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (f :*: g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> (f :*: g) a -> f0 ((f :*: g) b)

itraversed :: IndexedTraversal (Either i j) ((f :*: g) a) ((f :*: g) b) a b

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Product f g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Product f g a -> f0 (Product f g b)

itraversed :: IndexedTraversal (Either i j) (Product f g a) (Product f g b) a b

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Sum f g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => (Either i j -> a -> f0 b) -> Sum f g a -> f0 (Sum f g b)

itraversed :: IndexedTraversal (Either i j) (Sum f g a) (Sum f g b) a b

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (f :.: g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => ((i, j) -> a -> f0 b) -> (f :.: g) a -> f0 ((f :.: g) b)

itraversed :: IndexedTraversal (i, j) ((f :.: g) a) ((f :.: g) b) a b

(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (Compose f g)

Defined in Control.Lens.Indexed

Methods

itraverse :: Applicative f0 => ((i, j) -> a -> f0 b) -> Compose f g a -> f0 (Compose f g b)

itraversed :: IndexedTraversal (i, j) (Compose f g a) (Compose f g b) a b

Indexed Traversable Combinators

ifor :: (TraversableWithIndex i t, Applicative f) => t a -> (i -> a -> f b) -> f (t b)

Traverse with an index (and the arguments flipped).

for a ≡ ifor a . const
ifor ≡ flip itraverse

imapM :: (TraversableWithIndex i t, Monad m) => (i -> a -> m b) -> t a -> m (t b)

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

iforM :: (TraversableWithIndex i t, Monad m) => t a -> (i -> a -> m b) -> m (t b)

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results, with access its position (and the arguments flipped).

forM a ≡ iforM a . const
iforM ≡ flip imapM

imapAccumR :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)

Generalizes mapAccumR to add access to the index.

imapAccumROf accumulates state from right to left.

mapAccumR ≡ imapAccumR . const

imapAccumL :: TraversableWithIndex i t => (i -> s -> a -> (s, b)) -> s -> t a -> (s, t b)

Generalizes mapAccumL to add access to the index.

imapAccumLOf accumulates state from left to right.

mapAccumLOf ≡ imapAccumL . const

Indexed Folds with Reified Monoid

ifoldMapBy :: FoldableWithIndex i t => (r -> r -> r) -> r -> (i -> a -> r) -> t a -> r

ifoldMapByOf :: IndexedFold i t a -> (r -> r -> r) -> r -> (i -> a -> r) -> t -> r

Indexed Traversals with Reified Applicative

itraverseBy :: TraversableWithIndex i t => (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> t a -> f (t b)

itraverseByOf :: IndexedTraversal i s t a b -> (forall x. x -> f x) -> (forall x y. f (x -> y) -> f x -> f y) -> (i -> a -> f b) -> s -> f t