Optics.Indexed.Core

This module defines basic functionality for indexed optics. See the "Indexed optics" section of the overview documentation in the Optics module of the main optics package for more details.

Class for optic kinds that can be indexed

class IxOptic k s t a b where

Class for optic kinds that can have indices.

Methods

noIx :: NonEmptyIndices is => Optic k is s t a b -> Optic k NoIx s t a b

Convert an indexed optic to its unindexed equivalent.

Instances

(s ~ t, a ~ b) => IxOptic A_Fold s t a b

Defined in Optics.Indexed.Core

Methods

noIx :: forall (is :: IxList). NonEmptyIndices is => Optic A_Fold is s t a b -> Optic A_Fold NoIx s t a b

(s ~ t, a ~ b) => IxOptic An_AffineFold s t a b

Defined in Optics.Indexed.Core

Methods

noIx :: forall (is :: IxList). NonEmptyIndices is => Optic An_AffineFold is s t a b -> Optic An_AffineFold NoIx s t a b

(s ~ t, a ~ b) => IxOptic A_Getter s t a b

Defined in Optics.Indexed.Core

Methods

noIx :: forall (is :: IxList). NonEmptyIndices is => Optic A_Getter is s t a b -> Optic A_Getter NoIx s t a b

IxOptic A_Setter s t a b

Defined in Optics.Indexed.Core

Methods

noIx :: forall (is :: IxList). NonEmptyIndices is => Optic A_Setter is s t a b -> Optic A_Setter NoIx s t a b

IxOptic A_Traversal s t a b

Defined in Optics.Indexed.Core

Methods

noIx :: forall (is :: IxList). NonEmptyIndices is => Optic A_Traversal is s t a b -> Optic A_Traversal NoIx s t a b

IxOptic An_AffineTraversal s t a b

Defined in Optics.Indexed.Core

Methods

noIx :: forall (is :: IxList). NonEmptyIndices is => Optic An_AffineTraversal is s t a b -> Optic An_AffineTraversal NoIx s t a b

IxOptic A_Lens s t a b

Defined in Optics.Indexed.Core

Methods

noIx :: forall (is :: IxList). NonEmptyIndices is => Optic A_Lens is s t a b -> Optic A_Lens NoIx s t a b

conjoined :: is `HasSingleIndex` i => Optic k NoIx s t a b -> Optic k is s t a b -> Optic k is s t a b

Construct a conjoined indexed optic that provides a separate code path when used without indices. Useful for defining indexed optics that are as efficient as their unindexed equivalents when used without indices.

Note: conjoined f g is well-defined if and only if f ≡ noIx g.

Composition of indexed optics

(%) :: forall k l m is js ks s t u v a b. (JoinKinds k l m, AppendIndices is js ks) => Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b infixl 9

Compose two optics of compatible flavours.

Returns an optic of the appropriate supertype. If either or both optics are indexed, the composition preserves all the indices.

(<%>) :: (JoinKinds k l m, IxOptic m s t a b, is `HasSingleIndex` i, js `HasSingleIndex` j) => Optic k is s t u v -> Optic l js u v a b -> Optic m (WithIx (i, j)) s t a b infixl 9

Compose two indexed optics. Their indices are composed as a pair.

>>> itoListOf (ifolded <%> ifolded) ["foo", "bar"]
[((0,0),'f'),((0,1),'o'),((0,2),'o'),((1,0),'b'),((1,1),'a'),((1,2),'r')]

(%>) :: (JoinKinds k l m, IxOptic k s t u v, NonEmptyIndices is) => Optic k is s t u v -> Optic l js u v a b -> Optic m js s t a b infixl 9

Compose two indexed optics and drop indices of the left one. (If you want to compose a non-indexed and an indexed optic, you can just use (%).)

>>> itoListOf (ifolded %> ifolded) ["foo", "bar"]
[(0,'f'),(1,'o'),(2,'o'),(0,'b'),(1,'a'),(2,'r')]

(<%) :: (JoinKinds k l m, IxOptic l u v a b, NonEmptyIndices js) => Optic k is s t u v -> Optic l js u v a b -> Optic m is s t a b infixl 9

Compose two indexed optics and drop indices of the right one. (If you want to compose an indexed and a non-indexed optic, you can just use (%).)

>>> itoListOf (ifolded <% ifolded) ["foo", "bar"]
[(0,'f'),(0,'o'),(0,'o'),(1,'b'),(1,'a'),(1,'r')]

reindexed :: is `HasSingleIndex` i => (i -> j) -> Optic k is s t a b -> Optic k (WithIx j) s t a b

Remap the index.

>>> itoListOf (reindexed succ ifolded) "foo"
[(1,'f'),(2,'o'),(3,'o')]

>>> itoListOf (ifolded %& reindexed succ) "foo"
[(1,'f'),(2,'o'),(3,'o')]

icompose :: (i -> j -> ix) -> Optic k '[i, j] s t a b -> Optic k (WithIx ix) s t a b

Flatten indices obtained from two indexed optics.

>>> itoListOf (ifolded % ifolded %& icompose (,)) ["foo","bar"]
[((0,0),'f'),((0,1),'o'),((0,2),'o'),((1,0),'b'),((1,1),'a'),((1,2),'r')]

icompose3 :: (i1 -> i2 -> i3 -> ix) -> Optic k '[i1, i2, i3] s t a b -> Optic k (WithIx ix) s t a b

Flatten indices obtained from three indexed optics.

>>> itoListOf (ifolded % ifolded % ifolded %& icompose3 (,,)) [["foo","bar"],["xyz"]]
[((0,0,0),'f'),((0,0,1),'o'),((0,0,2),'o'),((0,1,0),'b'),((0,1,1),'a'),((0,1,2),'r'),((1,0,0),'x'),((1,0,1),'y'),((1,0,2),'z')]

icompose4 :: (i1 -> i2 -> i3 -> i4 -> ix) -> Optic k '[i1, i2, i3, i4] s t a b -> Optic k (WithIx ix) s t a b

Flatten indices obtained from four indexed optics.

icompose5 :: (i1 -> i2 -> i3 -> i4 -> i5 -> ix) -> Optic k '[i1, i2, i3, i4, i5] s t a b -> Optic k (WithIx ix) s t a b

Flatten indices obtained from five indexed optics.

icomposeN :: forall k i is s t a b. (CurryCompose is, NonEmptyIndices is) => Curry is i -> Optic k is s t a b -> Optic k (WithIx i) s t a b

Flatten indices obtained from arbitrary number of indexed optics.

Indexed optic flavours

module Optics.IxAffineFold

module Optics.IxAffineTraversal

module Optics.IxFold

module Optics.IxGetter

module Optics.IxLens

module Optics.IxSetter

module Optics.IxTraversal

Functors with index

class Functor f => FunctorWithIndex i (f :: Type -> Type) | 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.

Instances

FunctorWithIndex Int []

The position in the list is available as the index.

Defined in WithIndex

Methods

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

FunctorWithIndex Int ZipList

Same instance as for [].

Defined in WithIndex

Methods

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

FunctorWithIndex Int NonEmpty

Defined in WithIndex

Methods

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

FunctorWithIndex Int IntMap

Defined in WithIndex

Methods

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

FunctorWithIndex Int Seq

The position in the Seq is available as the index.

Defined in WithIndex

Methods

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

FunctorWithIndex () Maybe

Defined in WithIndex

Methods

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

FunctorWithIndex () Par1

Defined in WithIndex

Methods

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

FunctorWithIndex () Identity

Defined in WithIndex

Methods

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

FunctorWithIndex k (Map k)

Defined in WithIndex

Methods

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

FunctorWithIndex k ((,) k)

Defined in WithIndex

Methods

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

Ix i => FunctorWithIndex i (Array i)

Defined in WithIndex

Methods

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

FunctorWithIndex Void (V1 :: Type -> Type)

Defined in WithIndex

Methods

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

FunctorWithIndex Void (U1 :: Type -> Type)

Defined in WithIndex

Methods

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

FunctorWithIndex Void (Proxy :: Type -> Type)

Defined in WithIndex

Methods

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

FunctorWithIndex i f => FunctorWithIndex i (Reverse f)

Defined in WithIndex

Methods

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

FunctorWithIndex i f => FunctorWithIndex i (Rec1 f)

Defined in WithIndex

Methods

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

FunctorWithIndex i m => FunctorWithIndex i (IdentityT m)

Defined in WithIndex

Methods

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

FunctorWithIndex i f => FunctorWithIndex i (Backwards f)

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

FunctorWithIndex [Int] Tree

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

Foldable with index

class Foldable f => FoldableWithIndex i (f :: Type -> Type) | 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' :: Monoid m => (i -> a -> m) -> f a -> m

A variant of ifoldMap that is strict in the accumulator.

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

foldMap' ≡ ifoldMap' . const

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

foldr' ≡ 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.

foldl' l ≡ ifoldl' l . const

Instances

FoldableWithIndex Int []

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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

FoldableWithIndex k (Map k)

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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

Ix i => FoldableWithIndex i (Array i)

Defined in WithIndex

Methods

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

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

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 Void (V1 :: Type -> Type)

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 i f => FoldableWithIndex i (Reverse f)

Defined in WithIndex

Methods

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

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

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 (Rec1 f)

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 (Backwards f)

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 Void (K1 i c :: Type -> Type)

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 j g) => FoldableWithIndex (Either i j) (Sum f g)

Defined in WithIndex

Methods

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

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

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 (Either i j) (Product f g)

Defined in WithIndex

Methods

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

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

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) (f :+: g)

Defined in WithIndex

Methods

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

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

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 WithIndex

Methods

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

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

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 (i, j) (Compose f g)

Defined in WithIndex

Methods

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

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

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

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

Defined in WithIndex

Methods

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

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

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

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

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

Traversable with index

class (FunctorWithIndex i t, FoldableWithIndex i t, Traversable t) => TraversableWithIndex i (t :: Type -> Type) | 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

Instances

TraversableWithIndex Int []

Defined in WithIndex

Methods

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

TraversableWithIndex Int ZipList

Defined in WithIndex

Methods

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

TraversableWithIndex Int NonEmpty

Defined in WithIndex

Methods

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

TraversableWithIndex Int IntMap

Defined in WithIndex

Methods

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

TraversableWithIndex Int Seq

Defined in WithIndex

Methods

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

TraversableWithIndex () Maybe

Defined in WithIndex

Methods

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

TraversableWithIndex () Par1

Defined in WithIndex

Methods

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

TraversableWithIndex () Identity

Defined in WithIndex

Methods

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

TraversableWithIndex k (Map k)

Defined in WithIndex

Methods

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

TraversableWithIndex k ((,) k)

Defined in WithIndex

Methods

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

Ix i => TraversableWithIndex i (Array i)

Defined in WithIndex

Methods

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

TraversableWithIndex Void (V1 :: Type -> Type)

Defined in WithIndex

Methods

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

TraversableWithIndex Void (U1 :: Type -> Type)

Defined in WithIndex

Methods

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

TraversableWithIndex Void (Proxy :: Type -> Type)

Defined in WithIndex

Methods

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

TraversableWithIndex i f => TraversableWithIndex i (Reverse f)

Defined in WithIndex

Methods

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

TraversableWithIndex i f => TraversableWithIndex i (Rec1 f)

Defined in WithIndex

Methods

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

TraversableWithIndex i m => TraversableWithIndex i (IdentityT m)

Defined in WithIndex

Methods

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

TraversableWithIndex i f => TraversableWithIndex i (Backwards f)

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

TraversableWithIndex [Int] Tree

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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

Defined in WithIndex

Methods

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

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