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

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 :: (Constraints An_AffineFold p -> r) -> Constraints A_Fold p -> r

Is A_Getter A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: (Constraints A_Getter p -> r) -> Constraints A_Fold p -> r

Is A_ReversedPrism A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: (Constraints A_ReversedPrism p -> r) -> Constraints A_Fold p -> r

Is A_Traversal A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: (Constraints A_Traversal p -> r) -> Constraints A_Fold p -> r

Is An_AffineTraversal A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: (Constraints An_AffineTraversal p -> r) -> Constraints A_Fold p -> r

Is A_Prism A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: (Constraints A_Prism p -> r) -> Constraints A_Fold p -> r

Is A_Lens A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: (Constraints A_Lens p -> r) -> Constraints A_Fold p -> r

Is An_Iso A_Fold

Defined in Optics.Internal.Optic.Subtyping

Methods

implies :: (Constraints An_Iso p -> r) -> Constraints A_Fold p -> r

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

Defined in Optics.ReadOnly

Methods

getting :: Optic A_Fold is s t a b -> Optic' (Join A_Getter A_Fold) is s a

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

Defined in Optics.Indexed.Core

Methods

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

Re-exports

class (FunctorWithIndex i f, Foldable f) => FoldableWithIndex i f | f -> i where

Class for Foldables that have an additional read-only index available.

Minimal complete definition

Nothing

Methods

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

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

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

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

Instances

FoldableWithIndex Int []

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

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

FoldableWithIndex Int ZipList

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex Int NonEmpty

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex Int IntMap

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex Int Seq

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex () Maybe

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

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

FoldableWithIndex () Par1

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

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

FoldableWithIndex () Identity

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

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

Ix i => FoldableWithIndex i (Array i)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex k (Map k)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex k ((,) k)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex Void (V1 :: Type -> Type)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex Void (U1 :: Type -> Type)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex Void (Proxy :: Type -> Type)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex i f => FoldableWithIndex i (Rec1 f)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex i m => FoldableWithIndex i (IdentityT m)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex i f => FoldableWithIndex i (Reverse f)

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex i f => FoldableWithIndex i (Backwards f)

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Since: 0.3

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Since: 0.3

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Defined in Optics.Internal.Indexed.Classes

Methods

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

FoldableWithIndex [Int] Tree

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Defined in Optics.Internal.Indexed.Classes

Methods

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

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

Defined in Optics.Internal.Indexed.Classes

Methods

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