Copyright	(C) 2012-16 Edward Kmett
License	BSD-style (see the file LICENSE)
Maintainer	Edward Kmett <ekmett@gmail.com>
Stability	provisional
Portability	Rank2Types
Safe Haskell	Trustworthy
Language	Haskell98

Control.Lens.Indexed

Contents

Indexing
Indexed Functors
Indexed Foldables
- Indexed Foldable Combinators
Converting to Folds
Restricting by Index
Indexed Traversables
Indexed Traversable Combinators
Indexed Folds with Reified Monoid
Indexed Traversals with Reified Applicative

Description

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

Synopsis

Indexing

class Conjoined p => Indexable i p where Source

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 Source

Build a function from an indexed function.

Instances

Indexable i (->) Source
Methods indexed :: (a -> b) -> i -> a -> b Source
(~) * i j => Indexable i (Indexed j) Source
Methods indexed :: Indexed j a b -> i -> a -> b Source

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 Source

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) Source

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 Source

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 (->) Source
Methods distrib :: Functor f => (a -> b) -> f a -> f b Source conjoined :: (((* -> * -> *) ~ (->)) (->) -> q (a -> b) r) -> q (a -> b) r -> q (a -> b) r Source
Conjoined ReifiedGetter Source
Methods distrib :: Functor f => ReifiedGetter a b -> ReifiedGetter (f a) (f b) Source conjoined :: (((* -> * -> *) ~ ReifiedGetter) (->) -> q (a -> b) r) -> q (ReifiedGetter a b) r -> q (ReifiedGetter a b) r Source
Conjoined (Indexed i) Source
Methods distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b) Source conjoined :: (((* -> * -> *) ~ Indexed i) (->) -> q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r Source

newtype Indexed i a b Source

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

Category * (Indexed i) Source
Methods id :: Indexed i a a (.) :: Indexed i b c -> Indexed i a b -> Indexed i a c
(~) * i j => Indexable i (Indexed j) Source
Methods indexed :: Indexed j a b -> i -> a -> b Source
Arrow (Indexed i) Source
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) Source
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) Source
Methods app :: Indexed i (Indexed i b c, b) c
ArrowLoop (Indexed i) Source
Methods loop :: Indexed i (b, d) (c, d) -> Indexed i b c
Representable (Indexed i) Source
Associated Types type Rep (Indexed i :: * -> * -> ) :: -> * Methods tabulate :: (d -> Rep (Indexed i) c) -> Indexed i d c
Corepresentable (Indexed i) Source
Associated Types type Corep (Indexed i :: * -> * -> ) :: -> * Methods cotabulate :: (Corep (Indexed i) d -> c) -> Indexed i d c
Choice (Indexed i) Source
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) Source
Methods closed :: Indexed i a b -> Indexed i (x -> a) (x -> b)
Strong (Indexed i) Source
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) Source
Methods unfirst :: Indexed i (a, d) (b, d) -> Indexed i a b unsecond :: Indexed i (d, a) (d, b) -> Indexed i a b
Profunctor (Indexed i) Source
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 => (b -> c) -> Indexed i a b -> Indexed i a c (.#) :: Coercible * b a => Indexed i b c -> (a -> b) -> Indexed i a c
Conjoined (Indexed i) Source
Methods distrib :: Functor f => Indexed i a b -> Indexed i (f a) (f b) Source conjoined :: (((* -> * -> *) ~ Indexed i) (->) -> q (a -> b) r) -> q (Indexed i a b) r -> q (Indexed i a b) r Source
Bizarre (Indexed Int) Mafic Source
Methods bazaar :: Applicative f => Indexed Int a (f b) -> Mafic a b t -> f t Source
Sieve (Indexed i) ((->) i) Source
Methods sieve :: Indexed i a b -> a -> i -> b
Cosieve (Indexed i) ((,) i) Source
Methods cosieve :: Indexed i a b -> (i, a) -> b
Sellable (Indexed i) (Molten i) Source
Methods sell :: Indexed i a (Molten i a b b) Source
Bizarre (Indexed i) (Molten i) Source
Methods bazaar :: Applicative f => Indexed i a (f b) -> Molten i a b t -> f t Source
Monad (Indexed i a) Source
Methods (>>=) :: Indexed i a b -> (b -> Indexed i a c) -> Indexed i a c (>>) :: Indexed i a b -> Indexed i a c -> Indexed i a c return :: b -> Indexed i a b fail :: String -> Indexed i a b
Functor (Indexed i a) Source
Methods fmap :: (b -> c) -> Indexed i a b -> Indexed i a c (<$) :: b -> Indexed i a c -> Indexed i a b
MonadFix (Indexed i a) Source
Methods mfix :: (b -> Indexed i a b) -> Indexed i a b
Applicative (Indexed i a) Source
Methods pure :: b -> Indexed i a b (<>) :: Indexed i a (b -> c) -> Indexed i a b -> Indexed i a c (>) :: Indexed i a b -> Indexed i a c -> Indexed i a c (<*) :: Indexed i a b -> Indexed i a c -> Indexed i a b
Apply (Indexed i a) Source
Methods (<.>) :: Indexed i a (b -> c) -> Indexed i a b -> Indexed i a c (.>) :: Indexed i a b -> Indexed i a c -> Indexed i a c (<.) :: Indexed i a b -> Indexed i a c -> Indexed i a b
Bind (Indexed i a) Source
Methods (>>-) :: Indexed i a b -> (b -> Indexed i a c) -> Indexed i a c join :: Indexed i a (Indexed i a b) -> Indexed i a b
type Rep (Indexed i) = (->) i Source
type Corep (Indexed i) = (,) i Source

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

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 Source

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 Source

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 Source

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 Source

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 Source

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 Source

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 Source

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 Source

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 Source

Map with access to the index.

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

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 [] Source	The position in the list is available as the index.
Methods imap :: (Int -> a -> b) -> [a] -> [b] Source imapped :: (Indexable Int p, Settable f) => p a (f b) -> [a] -> f [b] Source
FunctorWithIndex Int IntMap Source
Methods imap :: (Int -> a -> b) -> IntMap a -> IntMap b Source imapped :: (Indexable Int p, Settable f) => p a (f b) -> IntMap a -> f (IntMap b) Source
FunctorWithIndex Int Seq Source	The position in the `Seq` is available as the index.
Methods imap :: (Int -> a -> b) -> Seq a -> Seq b Source imapped :: (Indexable Int p, Settable f) => p a (f b) -> Seq a -> f (Seq b) Source
FunctorWithIndex Int NonEmpty Source
Methods imap :: (Int -> a -> b) -> NonEmpty a -> NonEmpty b Source imapped :: (Indexable Int p, Settable f) => p a (f b) -> NonEmpty a -> f (NonEmpty b) Source
FunctorWithIndex Int Vector Source
Methods imap :: (Int -> a -> b) -> Vector a -> Vector b Source imapped :: (Indexable Int p, Settable f) => p a (f b) -> Vector a -> f (Vector b) Source
FunctorWithIndex Int Deque Source
Methods imap :: (Int -> a -> b) -> Deque a -> Deque b Source imapped :: (Indexable Int p, Settable f) => p a (f b) -> Deque a -> f (Deque b) Source
FunctorWithIndex () Identity Source
Methods imap :: (() -> a -> b) -> Identity a -> Identity b Source imapped :: (Indexable () p, Settable f) => p a (f b) -> Identity a -> f (Identity b) Source
FunctorWithIndex () Maybe Source
Methods imap :: (() -> a -> b) -> Maybe a -> Maybe b Source imapped :: (Indexable () p, Settable f) => p a (f b) -> Maybe a -> f (Maybe b) Source
FunctorWithIndex i m => FunctorWithIndex i (IdentityT m) Source
Methods imap :: (i -> a -> b) -> IdentityT m a -> IdentityT m b Source imapped :: (Indexable i p, Settable f) => p a (f b) -> IdentityT m a -> f (IdentityT m b) Source
Ix i => FunctorWithIndex i (Array i) Source
Methods imap :: (i -> a -> b) -> Array i a -> Array i b Source imapped :: (Indexable i p, Settable f) => p a (f b) -> Array i a -> f (Array i b) Source
FunctorWithIndex i (Level i) Source
Methods imap :: (i -> a -> b) -> Level i a -> Level i b Source imapped :: (Indexable i p, Settable f) => p a (f b) -> Level i a -> f (Level i b) Source
FunctorWithIndex r ((->) r) Source
Methods imap :: (r -> a -> b) -> (r -> a) -> r -> b Source imapped :: (Indexable r p, Settable f) => p a (f b) -> (r -> a) -> f (r -> b) Source
(Eq k, Hashable k) => FunctorWithIndex k (HashMap k) Source
Methods imap :: (k -> a -> b) -> HashMap k a -> HashMap k b Source imapped :: (Indexable k p, Settable f) => p a (f b) -> HashMap k a -> f (HashMap k b) Source
FunctorWithIndex k (Map k) Source
Methods imap :: (k -> a -> b) -> Map k a -> Map k b Source imapped :: (Indexable k p, Settable f) => p a (f b) -> Map k a -> f (Map k b) Source
FunctorWithIndex k ((,) k) Source
Methods imap :: (k -> a -> b) -> (k, a) -> (k, b) Source imapped :: (Indexable k p, Settable f) => p a (f b) -> (k, a) -> f (k, b) Source
FunctorWithIndex i f => FunctorWithIndex i (Reverse f) Source
Methods imap :: (i -> a -> b) -> Reverse f a -> Reverse f b Source imapped :: (Indexable i p, Settable c) => p a (c b) -> Reverse f a -> c (Reverse f b) Source
FunctorWithIndex i f => FunctorWithIndex i (Backwards f) Source
Methods imap :: (i -> a -> b) -> Backwards f a -> Backwards f b Source imapped :: (Indexable i p, Settable c) => p a (c b) -> Backwards f a -> c (Backwards f b) Source
FunctorWithIndex i (Magma i t b) Source
Methods imap :: (i -> a -> c) -> Magma i t b a -> Magma i t b c Source imapped :: (Indexable i p, Settable f) => p a (f c) -> Magma i t b a -> f (Magma i t b c) Source
FunctorWithIndex [Int] Tree Source
Methods imap :: ([Int] -> a -> b) -> Tree a -> Tree b Source imapped :: (Indexable [Int] p, Settable f) => p a (f b) -> Tree a -> f (Tree b) Source
FunctorWithIndex i f => FunctorWithIndex [i] (Cofree f) Source
Methods imap :: ([i] -> a -> b) -> Cofree f a -> Cofree f b Source imapped :: (Indexable [i] p, Settable c) => p a (c b) -> Cofree f a -> c (Cofree f b) Source
FunctorWithIndex i f => FunctorWithIndex [i] (Free f) Source
Methods imap :: ([i] -> a -> b) -> Free f a -> Free f b Source imapped :: (Indexable [i] p, Settable c) => p a (c b) -> Free f a -> c (Free f b) Source
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (Either i j) (Product f g) Source
Methods imap :: (Either i j -> a -> b) -> Product f g a -> Product f g b Source imapped :: (Indexable (Either i j) p, Settable c) => p a (c b) -> Product f g a -> c (Product f g b) Source
FunctorWithIndex i w => FunctorWithIndex (s, i) (TracedT s w) Source
Methods imap :: ((s, i) -> a -> b) -> TracedT s w a -> TracedT s w b Source imapped :: (Indexable (s, i) p, Settable f) => p a (f b) -> TracedT s w a -> f (TracedT s w b) Source
FunctorWithIndex i m => FunctorWithIndex (e, i) (ReaderT e m) Source
Methods imap :: ((e, i) -> a -> b) -> ReaderT e m a -> ReaderT e m b Source imapped :: (Indexable (e, i) p, Settable f) => p a (f b) -> ReaderT e m a -> f (ReaderT e m b) Source
(FunctorWithIndex i f, FunctorWithIndex j g) => FunctorWithIndex (i, j) (Compose f g) Source
Methods imap :: ((i, j) -> a -> b) -> Compose f g a -> Compose f g b Source imapped :: (Indexable (i, j) p, Settable c) => p a (c b) -> Compose f g a -> c (Compose f g b) Source

Indexed Foldables

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

A container that supports folding with an additional index.

Minimal complete definition

Nothing

Methods

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

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 Source

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 Source

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 Source

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 Source

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

foldr' ≡ ifoldr' . const

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

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 [] Source
Methods ifoldMap :: Monoid m => (Int -> a -> m) -> [a] -> m Source ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> [a] -> f [a] Source ifoldr :: (Int -> a -> b -> b) -> b -> [a] -> b Source ifoldl :: (Int -> b -> a -> b) -> b -> [a] -> b Source ifoldr' :: (Int -> a -> b -> b) -> b -> [a] -> b Source ifoldl' :: (Int -> b -> a -> b) -> b -> [a] -> b Source
FoldableWithIndex Int IntMap Source
Methods ifoldMap :: Monoid m => (Int -> a -> m) -> IntMap a -> m Source ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> IntMap a -> f (IntMap a) Source ifoldr :: (Int -> a -> b -> b) -> b -> IntMap a -> b Source ifoldl :: (Int -> b -> a -> b) -> b -> IntMap a -> b Source ifoldr' :: (Int -> a -> b -> b) -> b -> IntMap a -> b Source ifoldl' :: (Int -> b -> a -> b) -> b -> IntMap a -> b Source
FoldableWithIndex Int Seq Source
Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Seq a -> m Source ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> Seq a -> f (Seq a) Source ifoldr :: (Int -> a -> b -> b) -> b -> Seq a -> b Source ifoldl :: (Int -> b -> a -> b) -> b -> Seq a -> b Source ifoldr' :: (Int -> a -> b -> b) -> b -> Seq a -> b Source ifoldl' :: (Int -> b -> a -> b) -> b -> Seq a -> b Source
FoldableWithIndex Int NonEmpty Source
Methods ifoldMap :: Monoid m => (Int -> a -> m) -> NonEmpty a -> m Source ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> NonEmpty a -> f (NonEmpty a) Source ifoldr :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b Source ifoldl :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b Source ifoldr' :: (Int -> a -> b -> b) -> b -> NonEmpty a -> b Source ifoldl' :: (Int -> b -> a -> b) -> b -> NonEmpty a -> b Source
FoldableWithIndex Int Vector Source
Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Vector a -> m Source ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> Vector a -> f (Vector a) Source ifoldr :: (Int -> a -> b -> b) -> b -> Vector a -> b Source ifoldl :: (Int -> b -> a -> b) -> b -> Vector a -> b Source ifoldr' :: (Int -> a -> b -> b) -> b -> Vector a -> b Source ifoldl' :: (Int -> b -> a -> b) -> b -> Vector a -> b Source
FoldableWithIndex Int Deque Source
Methods ifoldMap :: Monoid m => (Int -> a -> m) -> Deque a -> m Source ifolded :: (Indexable Int p, Contravariant f, Applicative f) => p a (f a) -> Deque a -> f (Deque a) Source ifoldr :: (Int -> a -> b -> b) -> b -> Deque a -> b Source ifoldl :: (Int -> b -> a -> b) -> b -> Deque a -> b Source ifoldr' :: (Int -> a -> b -> b) -> b -> Deque a -> b Source ifoldl' :: (Int -> b -> a -> b) -> b -> Deque a -> b Source
FoldableWithIndex () Identity Source
Methods ifoldMap :: Monoid m => (() -> a -> m) -> Identity a -> m Source ifolded :: (Indexable () p, Contravariant f, Applicative f) => p a (f a) -> Identity a -> f (Identity a) Source ifoldr :: (() -> a -> b -> b) -> b -> Identity a -> b Source ifoldl :: (() -> b -> a -> b) -> b -> Identity a -> b Source ifoldr' :: (() -> a -> b -> b) -> b -> Identity a -> b Source ifoldl' :: (() -> b -> a -> b) -> b -> Identity a -> b Source
FoldableWithIndex () Maybe Source
Methods ifoldMap :: Monoid m => (() -> a -> m) -> Maybe a -> m Source ifolded :: (Indexable () p, Contravariant f, Applicative f) => p a (f a) -> Maybe a -> f (Maybe a) Source ifoldr :: (() -> a -> b -> b) -> b -> Maybe a -> b Source ifoldl :: (() -> b -> a -> b) -> b -> Maybe a -> b Source ifoldr' :: (() -> a -> b -> b) -> b -> Maybe a -> b Source ifoldl' :: (() -> b -> a -> b) -> b -> Maybe a -> b Source
FoldableWithIndex i m => FoldableWithIndex i (IdentityT m) Source
Methods ifoldMap :: Monoid b => (i -> a -> b) -> IdentityT m a -> b Source ifolded :: (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> IdentityT m a -> f (IdentityT m a) Source ifoldr :: (i -> a -> b -> b) -> b -> IdentityT m a -> b Source ifoldl :: (i -> b -> a -> b) -> b -> IdentityT m a -> b Source ifoldr' :: (i -> a -> b -> b) -> b -> IdentityT m a -> b Source ifoldl' :: (i -> b -> a -> b) -> b -> IdentityT m a -> b Source
Ix i => FoldableWithIndex i (Array i) Source
Methods ifoldMap :: Monoid m => (i -> a -> m) -> Array i a -> m Source ifolded :: (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> Array i a -> f (Array i a) Source ifoldr :: (i -> a -> b -> b) -> b -> Array i a -> b Source ifoldl :: (i -> b -> a -> b) -> b -> Array i a -> b Source ifoldr' :: (i -> a -> b -> b) -> b -> Array i a -> b Source ifoldl' :: (i -> b -> a -> b) -> b -> Array i a -> b Source
FoldableWithIndex i (Level i) Source
Methods ifoldMap :: Monoid m => (i -> a -> m) -> Level i a -> m Source ifolded :: (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> Level i a -> f (Level i a) Source ifoldr :: (i -> a -> b -> b) -> b -> Level i a -> b Source ifoldl :: (i -> b -> a -> b) -> b -> Level i a -> b Source ifoldr' :: (i -> a -> b -> b) -> b -> Level i a -> b Source ifoldl' :: (i -> b -> a -> b) -> b -> Level i a -> b Source
(Eq k, Hashable k) => FoldableWithIndex k (HashMap k) Source
Methods ifoldMap :: Monoid m => (k -> a -> m) -> HashMap k a -> m Source ifolded :: (Indexable k p, Contravariant f, Applicative f) => p a (f a) -> HashMap k a -> f (HashMap k a) Source ifoldr :: (k -> a -> b -> b) -> b -> HashMap k a -> b Source ifoldl :: (k -> b -> a -> b) -> b -> HashMap k a -> b Source ifoldr' :: (k -> a -> b -> b) -> b -> HashMap k a -> b Source ifoldl' :: (k -> b -> a -> b) -> b -> HashMap k a -> b Source
FoldableWithIndex k (Map k) Source
Methods ifoldMap :: Monoid m => (k -> a -> m) -> Map k a -> m Source ifolded :: (Indexable k p, Contravariant f, Applicative f) => p a (f a) -> Map k a -> f (Map k a) Source ifoldr :: (k -> a -> b -> b) -> b -> Map k a -> b Source ifoldl :: (k -> b -> a -> b) -> b -> Map k a -> b Source ifoldr' :: (k -> a -> b -> b) -> b -> Map k a -> b Source ifoldl' :: (k -> b -> a -> b) -> b -> Map k a -> b Source
FoldableWithIndex k ((,) k) Source
Methods ifoldMap :: Monoid m => (k -> a -> m) -> (k, a) -> m Source ifolded :: (Indexable k p, Contravariant f, Applicative f) => p a (f a) -> (k, a) -> f (k, a) Source ifoldr :: (k -> a -> b -> b) -> b -> (k, a) -> b Source ifoldl :: (k -> b -> a -> b) -> b -> (k, a) -> b Source ifoldr' :: (k -> a -> b -> b) -> b -> (k, a) -> b Source ifoldl' :: (k -> b -> a -> b) -> b -> (k, a) -> b Source
FoldableWithIndex i f => FoldableWithIndex i (Reverse f) Source
Methods ifoldMap :: Monoid m => (i -> a -> m) -> Reverse f a -> m Source ifolded :: (Indexable i p, Contravariant b, Applicative b) => p a (b a) -> Reverse f a -> b (Reverse f a) Source ifoldr :: (i -> a -> b -> b) -> b -> Reverse f a -> b Source ifoldl :: (i -> b -> a -> b) -> b -> Reverse f a -> b Source ifoldr' :: (i -> a -> b -> b) -> b -> Reverse f a -> b Source ifoldl' :: (i -> b -> a -> b) -> b -> Reverse f a -> b Source
FoldableWithIndex i f => FoldableWithIndex i (Backwards f) Source
Methods ifoldMap :: Monoid m => (i -> a -> m) -> Backwards f a -> m Source ifolded :: (Indexable i p, Contravariant b, Applicative b) => p a (b a) -> Backwards f a -> b (Backwards f a) Source ifoldr :: (i -> a -> b -> b) -> b -> Backwards f a -> b Source ifoldl :: (i -> b -> a -> b) -> b -> Backwards f a -> b Source ifoldr' :: (i -> a -> b -> b) -> b -> Backwards f a -> b Source ifoldl' :: (i -> b -> a -> b) -> b -> Backwards f a -> b Source
FoldableWithIndex i (Magma i t b) Source
Methods ifoldMap :: Monoid m => (i -> a -> m) -> Magma i t b a -> m Source ifolded :: (Indexable i p, Contravariant f, Applicative f) => p a (f a) -> Magma i t b a -> f (Magma i t b a) Source ifoldr :: (i -> a -> c -> c) -> c -> Magma i t b a -> c Source ifoldl :: (i -> a -> c -> a) -> a -> Magma i t b c -> a Source ifoldr' :: (i -> a -> c -> c) -> c -> Magma i t b a -> c Source ifoldl' :: (i -> a -> c -> a) -> a -> Magma i t b c -> a Source
FoldableWithIndex [Int] Tree Source
Methods ifoldMap :: Monoid m => ([Int] -> a -> m) -> Tree a -> m Source ifolded :: (Indexable [Int] p, Contravariant f, Applicative f) => p a (f a) -> Tree a -> f (Tree a) Source ifoldr :: ([Int] -> a -> b -> b) -> b -> Tree a -> b Source ifoldl :: ([Int] -> b -> a -> b) -> b -> Tree a -> b Source ifoldr' :: ([Int] -> a -> b -> b) -> b -> Tree a -> b Source ifoldl' :: ([Int] -> b -> a -> b) -> b -> Tree a -> b Source
FoldableWithIndex i f => FoldableWithIndex [i] (Cofree f) Source
Methods ifoldMap :: Monoid m => ([i] -> a -> m) -> Cofree f a -> m Source ifolded :: (Indexable [i] p, Contravariant b, Applicative b) => p a (b a) -> Cofree f a -> b (Cofree f a) Source ifoldr :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b Source ifoldl :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b Source ifoldr' :: ([i] -> a -> b -> b) -> b -> Cofree f a -> b Source ifoldl' :: ([i] -> b -> a -> b) -> b -> Cofree f a -> b Source
FoldableWithIndex i f => FoldableWithIndex [i] (Free f) Source
Methods ifoldMap :: Monoid m => ([i] -> a -> m) -> Free f a -> m Source ifolded :: (Indexable [i] p, Contravariant b, Applicative b) => p a (b a) -> Free f a -> b (Free f a) Source ifoldr :: ([i] -> a -> b -> b) -> b -> Free f a -> b Source ifoldl :: ([i] -> b -> a -> b) -> b -> Free f a -> b Source ifoldr' :: ([i] -> a -> b -> b) -> b -> Free f a -> b Source ifoldl' :: ([i] -> b -> a -> b) -> b -> Free f a -> b Source
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (Either i j) (Product f g) Source
Methods ifoldMap :: Monoid m => (Either i j -> a -> m) -> Product f g a -> m Source ifolded :: (Indexable (Either i j) p, Contravariant b, Applicative b) => p a (b a) -> Product f g a -> b (Product f g a) Source ifoldr :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b Source ifoldl :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b Source ifoldr' :: (Either i j -> a -> b -> b) -> b -> Product f g a -> b Source ifoldl' :: (Either i j -> b -> a -> b) -> b -> Product f g a -> b Source
(FoldableWithIndex i f, FoldableWithIndex j g) => FoldableWithIndex (i, j) (Compose f g) Source
Methods ifoldMap :: Monoid m => ((i, j) -> a -> m) -> Compose f g a -> m Source ifolded :: (Indexable (i, j) p, Contravariant b, Applicative b) => p a (b a) -> Compose f g a -> b (Compose f g a) Source ifoldr :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b Source ifoldl :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b Source ifoldr' :: ((i, j) -> a -> b -> b) -> b -> Compose f g a -> b Source ifoldl' :: ((i, j) -> b -> a -> b) -> b -> Compose f g a -> b Source

Indexed Foldable Combinators

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

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 Source

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 Source

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 Source

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 () Source

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 () Source

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 () Source

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 () Source

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] Source

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) Source

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 Source

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 Source

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)] Source

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) Source

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.

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

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 Source

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 Source

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 Source

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) Source

Traverse an indexed container.

itraverse ≡ itraverseOf itraversed

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

The IndexedTraversal of a TraversableWithIndex container.

Instances

TraversableWithIndex Int [] Source
Methods itraverse :: Applicative f => (Int -> a -> f b) -> [a] -> f [b] Source itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> [a] -> f [b] Source
TraversableWithIndex Int IntMap Source
Methods itraverse :: Applicative f => (Int -> a -> f b) -> IntMap a -> f (IntMap b) Source itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> IntMap a -> f (IntMap b) Source
TraversableWithIndex Int Seq Source
Methods itraverse :: Applicative f => (Int -> a -> f b) -> Seq a -> f (Seq b) Source itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> Seq a -> f (Seq b) Source
TraversableWithIndex Int NonEmpty Source
Methods itraverse :: Applicative f => (Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b) Source itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> NonEmpty a -> f (NonEmpty b) Source
TraversableWithIndex Int Vector Source
Methods itraverse :: Applicative f => (Int -> a -> f b) -> Vector a -> f (Vector b) Source itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> Vector a -> f (Vector b) Source
TraversableWithIndex Int Deque Source
Methods itraverse :: Applicative f => (Int -> a -> f b) -> Deque a -> f (Deque b) Source itraversed :: (Indexable Int p, Applicative f) => p a (f b) -> Deque a -> f (Deque b) Source
TraversableWithIndex () Identity Source
Methods itraverse :: Applicative f => (() -> a -> f b) -> Identity a -> f (Identity b) Source itraversed :: (Indexable () p, Applicative f) => p a (f b) -> Identity a -> f (Identity b) Source
TraversableWithIndex () Maybe Source
Methods itraverse :: Applicative f => (() -> a -> f b) -> Maybe a -> f (Maybe b) Source itraversed :: (Indexable () p, Applicative f) => p a (f b) -> Maybe a -> f (Maybe b) Source
TraversableWithIndex i m => TraversableWithIndex i (IdentityT m) Source
Methods itraverse :: Applicative f => (i -> a -> f b) -> IdentityT m a -> f (IdentityT m b) Source itraversed :: (Indexable i p, Applicative f) => p a (f b) -> IdentityT m a -> f (IdentityT m b) Source
Ix i => TraversableWithIndex i (Array i) Source
Methods itraverse :: Applicative f => (i -> a -> f b) -> Array i a -> f (Array i b) Source itraversed :: (Indexable i p, Applicative f) => p a (f b) -> Array i a -> f (Array i b) Source
TraversableWithIndex i (Level i) Source
Methods itraverse :: Applicative f => (i -> a -> f b) -> Level i a -> f (Level i b) Source itraversed :: (Indexable i p, Applicative f) => p a (f b) -> Level i a -> f (Level i b) Source
(Eq k, Hashable k) => TraversableWithIndex k (HashMap k) Source
Methods itraverse :: Applicative f => (k -> a -> f b) -> HashMap k a -> f (HashMap k b) Source itraversed :: (Indexable k p, Applicative f) => p a (f b) -> HashMap k a -> f (HashMap k b) Source
TraversableWithIndex k (Map k) Source
Methods itraverse :: Applicative f => (k -> a -> f b) -> Map k a -> f (Map k b) Source itraversed :: (Indexable k p, Applicative f) => p a (f b) -> Map k a -> f (Map k b) Source
TraversableWithIndex k ((,) k) Source
Methods itraverse :: Applicative f => (k -> a -> f b) -> (k, a) -> f (k, b) Source itraversed :: (Indexable k p, Applicative f) => p a (f b) -> (k, a) -> f (k, b) Source
TraversableWithIndex i f => TraversableWithIndex i (Reverse f) Source
Methods itraverse :: Applicative b => (i -> a -> b c) -> Reverse f a -> b (Reverse f c) Source itraversed :: (Indexable i p, Applicative c) => p a (c b) -> Reverse f a -> c (Reverse f b) Source
TraversableWithIndex i f => TraversableWithIndex i (Backwards f) Source
Methods itraverse :: Applicative b => (i -> a -> b c) -> Backwards f a -> b (Backwards f c) Source itraversed :: (Indexable i p, Applicative c) => p a (c b) -> Backwards f a -> c (Backwards f b) Source
TraversableWithIndex i (Magma i t b) Source
Methods itraverse :: Applicative f => (i -> a -> f c) -> Magma i t b a -> f (Magma i t b c) Source itraversed :: (Indexable i p, Applicative f) => p a (f c) -> Magma i t b a -> f (Magma i t b c) Source
TraversableWithIndex [Int] Tree Source
Methods itraverse :: Applicative f => ([Int] -> a -> f b) -> Tree a -> f (Tree b) Source itraversed :: (Indexable [Int] p, Applicative f) => p a (f b) -> Tree a -> f (Tree b) Source
TraversableWithIndex i f => TraversableWithIndex [i] (Cofree f) Source
Methods itraverse :: Applicative b => ([i] -> a -> b c) -> Cofree f a -> b (Cofree f c) Source itraversed :: (Indexable [i] p, Applicative c) => p a (c b) -> Cofree f a -> c (Cofree f b) Source
TraversableWithIndex i f => TraversableWithIndex [i] (Free f) Source
Methods itraverse :: Applicative b => ([i] -> a -> b c) -> Free f a -> b (Free f c) Source itraversed :: (Indexable [i] p, Applicative c) => p a (c b) -> Free f a -> c (Free f b) Source
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (Either i j) (Product f g) Source
Methods itraverse :: Applicative b => (Either i j -> a -> b c) -> Product f g a -> b (Product f g c) Source itraversed :: (Indexable (Either i j) p, Applicative c) => p a (c b) -> Product f g a -> c (Product f g b) Source
(TraversableWithIndex i f, TraversableWithIndex j g) => TraversableWithIndex (i, j) (Compose f g) Source
Methods itraverse :: Applicative b => ((i, j) -> a -> b c) -> Compose f g a -> b (Compose f g c) Source itraversed :: (Indexable (i, j) p, Applicative c) => p a (c b) -> Compose f g a -> c (Compose f g b) Source

Indexed Traversable Combinators

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

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) Source

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) Source

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) Source

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) Source

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 Source

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

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) Source

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 Source