Optics.IxFold

An IxFold is an indexed version of a Fold. See the "Indexed optics" section of the overview documentation in the Optics module of the main optics package for more details on indexed optics.

Formation

type IxFold i s a = Optic' A_Fold (WithIx i) s a

Type synonym for an indexed fold.

Introduction

ifoldVL :: (forall f. Applicative f => (i -> a -> f u) -> s -> f v) -> IxFold i s a

Obtain an indexed fold by lifting itraverse_ like function.

ifoldVL . itraverseOf_ ≡ id
itraverseOf_ . ifoldVL ≡ id

Elimination

ifoldMapOf :: (Is k A_Fold, Monoid m, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> m) -> s -> m

Fold with index via embedding into a monoid.

ifoldrOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> r -> r) -> r -> s -> r

Fold with index right-associatively.

ifoldlOf' :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> (i -> r -> a -> r) -> r -> s -> r

Fold with index left-associatively, and strictly.

itoListOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> s -> [(i, a)]

Fold with index to a list.

>>> itoListOf (folded % ifolded) ["abc", "def"]
[(0,'a'),(1,'b'),(2,'c'),(0,'d'),(1,'e'),(2,'f')]

Note: currently indexed optics can be used as non-indexed.

>>> toListOf (folded % ifolded) ["abc", "def"]
"abcdef"

itraverseOf_ :: (Is k A_Fold, Applicative f, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> f r) -> s -> f ()

Traverse over all of the targets of an IxFold, computing an Applicative-based answer, but unlike itraverseOf do not construct a new structure.

>>> itraverseOf_ each (curry print) ("hello","world")
(0,"hello")
(1,"world")

iforOf_ :: (Is k A_Fold, Applicative f, is `HasSingleIndex` i) => Optic' k is s a -> s -> (i -> a -> f r) -> f ()

A version of itraverseOf_ with the arguments flipped.

Additional introduction forms

ifolded :: FoldableWithIndex i f => IxFold i (f a) a

Indexed fold via FoldableWithIndex class.

ifolding :: FoldableWithIndex i f => (s -> f a) -> IxFold i s a

Obtain an IxFold by lifting an operation that returns a FoldableWithIndex result.

This can be useful to lift operations from Data.List and elsewhere into an IxFold.

>>> itoListOf (ifolding words) "how are you"
[(0,"how"),(1,"are"),(2,"you")]

ifoldring :: (forall f. Applicative f => (i -> a -> f u -> f u) -> f v -> s -> f w) -> IxFold i s a

Obtain an IxFold by lifting ifoldr like function.

>>> itoListOf (ifoldring ifoldr) "hello"
[(0,'h'),(1,'e'),(2,'l'),(3,'l'),(4,'o')]

Additional elimination forms

See also toMapOf, which constructs a Map from an IxFold.

iheadOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> s -> Maybe (i, a)

Retrieve the first entry of an IxFold along with its index.

>>> iheadOf ifolded [1..10]
Just (0,1)

ilastOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> s -> Maybe (i, a)

Retrieve the last entry of an IxFold along with its index.

>>> ilastOf ifolded [1..10]
Just (9,10)

ianyOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> Bool) -> s -> Bool

Return whether or not any element viewed through an IxFold satisfies a predicate, with access to the i.

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

anyOf o ≡ ianyOf o . const

iallOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> Bool) -> s -> Bool

Return whether or not all elements viewed through an IxFold satisfy a predicate, with access to the i.

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

allOf o ≡ iallOf o . const

inoneOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> Bool) -> s -> Bool

Return whether or not none of the elements viewed through an IxFold satisfy a predicate, with access to the i.

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

noneOf o ≡ inoneOf o . const

ifindOf :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> Bool) -> s -> Maybe (i, a)

The ifindOf function takes an IxFold, a predicate that is also supplied the index, a structure and returns the left-most element of the structure along with its index matching the predicate, or Nothing if there is no such element.

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

ifindMOf :: (Is k A_Fold, Monad m, is `HasSingleIndex` i) => Optic' k is s a -> (i -> a -> m Bool) -> s -> m (Maybe (i, a))

The ifindMOf function takes an IxFold, a monadic predicate that is also supplied the index, a structure and returns in the monad 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 findMOf is more flexible in what it accepts.

Combinators

ipre :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> IxAffineFold i s a

Convert an indexed fold to an IxAffineFold that visits the first element of the original fold.

For the traversal version see isingular.

ifiltered :: (Is k A_Fold, is `HasSingleIndex` i) => (i -> a -> Bool) -> Optic' k is s a -> IxFold i s a

Filter results of an IxFold that don't satisfy a predicate.

>>> toListOf (ifolded %& ifiltered (>)) [3,2,1,0]
[1,0]

ibackwards_ :: (Is k A_Fold, is `HasSingleIndex` i) => Optic' k is s a -> IxFold i s a

This allows you to traverse the elements of an IxFold in the opposite order.

Monoid structures

IxFold admits (at least) two monoid structures:

• isumming concatenates results from both folds.
• ifailing returns results from the second fold only if the first returns no results.

In both cases, the identity element of the monoid is ignored, which returns no results.

There is no Semigroup or Monoid instance for IxFold, because there is not a unique choice of monoid to use, and the (<>) operator could not be used to combine optics of different kinds.

isumming :: (Is k A_Fold, Is l A_Fold, is1 `HasSingleIndex` i, is2 `HasSingleIndex` i) => Optic' k is1 s a -> Optic' l is2 s a -> IxFold i s a infixr 6

Return entries of the first IxFold, then the second one.

>>> itoListOf (ifolded `isumming` ibackwards_ ifolded) ["a","b"]
[(0,"a"),(1,"b"),(1,"b"),(0,"a")]

For the traversal version see iadjoin.

ifailing :: (Is k A_Fold, Is l A_Fold, is1 `HasSingleIndex` i, is2 `HasSingleIndex` i) => Optic' k is1 s a -> Optic' l is2 s a -> IxFold i s a infixl 3

Try the first IxFold. If it returns no entries, try the second one.

>>> itoListOf (_1 % ifolded `ifailing` _2 % ifolded) (["a"], ["b","c"])
[(0,"a")]
>>> itoListOf (_1 % ifolded `ifailing` _2 % ifolded) ([], ["b","c"])
[(0,"b"),(1,"c")]

Subtyping

data A_Fold :: OpticKind

Tag for a fold.

Instances

Is An_AffineFold A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints An_AffineFold p => r) -> Constraints A_Fold p => r

Is A_Getter A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Getter p => r) -> Constraints A_Fold p => r

Is A_ReversedPrism A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_ReversedPrism p => r) -> Constraints A_Fold p => r

Is A_Traversal A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Traversal p => r) -> Constraints A_Fold p => r

Is An_AffineTraversal A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints An_AffineTraversal p => r) -> Constraints A_Fold p => r

Is A_Prism A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Prism p => r) -> Constraints A_Fold p => r

Is A_Lens A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints A_Lens p => r) -> Constraints A_Fold p => r

Is An_Iso A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: forall (p :: Type -> Type -> Type -> Type) r. (Constraints An_Iso p => r) -> Constraints A_Fold p => r

k ~ A_Fold => JoinKinds A_Fold A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold An_AffineFold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints An_AffineFold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold A_Getter k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Getter p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold A_ReversedPrism k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_ReversedPrism p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold A_Traversal k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Traversal p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold An_AffineTraversal k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints An_AffineTraversal p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold A_Prism k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Prism p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold A_Lens k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints A_Lens p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Fold An_Iso k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Fold p, Constraints An_Iso p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds An_AffineFold A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints An_AffineFold p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Getter A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Getter p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_ReversedPrism A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_ReversedPrism p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Traversal A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Traversal p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds An_AffineTraversal A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints An_AffineTraversal p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Prism A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Prism p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds A_Lens A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints A_Lens p, Constraints A_Fold p) => r) -> Constraints k p => r

k ~ A_Fold => JoinKinds An_Iso A_Fold k

Defined in Optics.Internal.Optic.Subtyping

Methods

joinKinds :: forall (p :: Type -> Type -> Type -> Type) r. ((Constraints An_Iso p, Constraints A_Fold p) => r) -> Constraints k p => r

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

Defined in Optics.ReadOnly

Associated Types

type ReadOnlyOptic A_Fold

Methods

getting :: forall (is :: IxList). Optic A_Fold is s t a b -> Optic' (ReadOnlyOptic A_Fold) is s a

(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

type ReadOnlyOptic A_Fold

Defined in Optics.ReadOnly

type ReadOnlyOptic A_Fold = A_Fold

Re-exports

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