Optics.IxTraversal

Type synonym for a type-modifying indexed traversal.

Type synonym for a type-preserving indexed traversal.

Build an indexed traversal from the van Laarhoven representation.

itraversalVL . itraverseOf ≡ id
itraverseOf . itraversalVL ≡ id

Map each element of a structure targeted by an IxTraversal (supplying the index), evaluate these actions from left to right, and collect the results.

This yields the van Laarhoven representation of an indexed traversal.

Indexed traversal via the TraversableWithIndex class.

itraverseOf itraversed ≡ itraverse

>>> iover (itraversed <%> itraversed) (,) ["ab", "cd"][[((0,0),'a'),((0,1),'b')],[((1,0),'c'),((1,1),'d')]]

This is the trivial empty IxAffineTraversal, i.e. the optic that targets no substructures.

This is the identity element when a Fold, AffineFold, IxFold, IxAffineFold, Traversal or IxTraversal is viewed as a monoid.

>>> 6 & ignored %~ absurd6

Traverse selected elements of a Traversal where their ordinal positions match a predicate.

Traverse elements of a Traversable container where their ordinal positions match a predicate.

elements ≡ elementsOf traverse

Traverse the nth element of a Traversal if it exists.

Traverse the nth element of a Traversable container.

element ≡ elementOf traversed

A version of itraverseOf with the arguments flipped.

Generalizes mapAccumL to an arbitrary IxTraversal.

imapAccumLOf accumulates state from left to right.

mapAccumLOf o ≡ imapAccumLOf o . const

Generalizes mapAccumR to an arbitrary IxTraversal.

imapAccumROf accumulates state from right to left.

mapAccumROf o ≡ imapAccumROf o . const

This permits the use of scanl1 over an arbitrary IxTraversal.

This permits the use of scanr1 over an arbitrary IxTraversal.

Try to map a function which uses the index over this IxTraversal, returning Nothing if the IxTraversal has no targets.

Version of ifailover strict in the application of the function.

Filter results of an IxTraversal that don't satisfy a predicate on the indices.

>>> toListOf (itraversed %& indices even) "foobar""foa"

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

An indexed version of partsOf that receives the entire list of indices as its indices.

Convert an indexed traversal to an IxAffineTraversal that visits the first element of the original traversal.

For the fold version see ipre.

>>> [1,2,3] & iover (isingular itraversed) (-)[-1,2,3]

Combine two disjoint indexed traversals into one.

>>> iover (_1 % itraversed `iadjoin` _2 % itraversed) (+) ([0, 0, 0], (3, 5))([0,1,2],(3,8))

Note: if the argument traversals are not disjoint, the result will not respect the IxTraversal laws, because it will visit the same element multiple times. See section 7 of Understanding Idiomatic Traversals Backwards and Forwards by Bird et al. for why this is illegal.

>>> iview (ipartsOf (each `iadjoin` each)) ("x","y")([0,1,0,1],["x","y","x","y"])>>> iset (ipartsOf (each `iadjoin` each)) (const ["a","b","c","d"]) ("x","y")("c","d")

For the IxFold version see isumming.

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

>>> iover (_1 % itraversed `idisjoin` _2 % itraversed) (+) ([0, 0, 0], (3, 5))([0,1,2],(3,5))

>>> iover (ignored `idisjoin` _2 % itraversed) (+) ([0, 0, 0], (3, 5))([0,0,0],(3,8))

Tag for a traversal.

Type synonym for a type-modifying van Laarhoven indexed traversal.

Type synonym for a type-preserving van Laarhoven indexed traversal.

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)