Optics.Traversal

Type synonym for a type-modifying traversal.

Type synonym for a type-preserving traversal.

Build a traversal from the van Laarhoven representation.

traversalVL . traverseOf ≡ id
traverseOf . traversalVL ≡ id

Map each element of a structure targeted by a Traversal, evaluate these actions from left to right, and collect the results.

Construct a Traversal via the Traversable class.

traverseOf traversed = traverse

Traverse both parts of a Bitraversable container with matching types.

Note: for traversing a pair or an Either it's better to use each and chosen respectively to reduce potential for bugs due to too much polymorphism.

>>> (1,2) & both %~ (*10)(10,20)

>>> over both length ("hello","world")(5,5)

>>> foldOf both ("hello","world")"helloworld"

A version of traverseOf with the arguments flipped.

Evaluate each action in the structure from left to right, and collect the results.

>>> sequenceOf each ([1,2],[3,4])[(1,3),(1,4),(2,3),(2,4)]

sequence ≡ sequenceOf traversed ≡ traverse id
sequenceOf o ≡ traverseOf o id

This generalizes transpose to an arbitrary Traversal.

Note: transpose handles ragged inputs more intelligently, but for non-ragged inputs:

>>> transposeOf traversed [[1,2,3],[4,5,6]][[1,4],[2,5],[3,6]]

transpose ≡ transposeOf traverse

This generalizes Data.Traversable.mapAccumR to an arbitrary Traversal.

Data.Traversable.mapAccumR ≡ mapAccumROf traversed

mapAccumROf accumulates State from right to left.

This generalizes Data.Traversable.mapAccumL to an arbitrary Traversal.

Data.Traversable.mapAccumL ≡ mapAccumLOf traverse

mapAccumLOf accumulates State from left to right.

This permits the use of scanr1 over an arbitrary Traversal.

scanr1 ≡ scanr1Of traversed

This permits the use of scanl1 over an arbitrary Traversal.

scanl1 ≡ scanl1Of traversed

Rewrite by applying a monadic rule everywhere you recursing with a user-specified Traversal.

Ensures that the rule cannot be applied anywhere in the result.

Transform every element in a tree using a user supplied Traversal in a bottom-up manner with a monadic effect.

Try to map a function over this Traversal, returning Nothing if the traversal has no targets.

>>> failover (element 3) (*2) [1,2]Nothing

>>> failover _Left (*2) (Right 4)Nothing

>>> failover _Right (*2) (Right 4)Just (Right 8)

Version of failover strict in the application of f.

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

partsOf turns a Traversal into a Lens.

Note: You should really try to maintain the invariant of the number of children in the list.

>>> ('a','b','c') & partsOf each .~ ['x','y','z']('x','y','z')

Any extras will be lost. If you do not supply enough, then the remainder will come from the original structure.

>>> ('a','b','c') & partsOf each .~ ['w','x','y','z']('w','x','y')

>>> ('a','b','c') & partsOf each .~ ['x','y']('x','y','c')

>>> ('b', 'a', 'd', 'c') & partsOf each %~ sort('a','b','c','d')

So technically, this is only a Lens if you do not change the number of results it returns.

Convert a traversal to an AffineTraversal that visits the first element of the original traversal.

For the fold version see pre.

>>> "foo" & singular traversed .~ 'z'"zoo"

Combine two disjoint traversals into one.

>>> over (_1 % _Just `adjoin` _2 % _Right) not (Just True, Right False)(Just False,Right True)

Note: if the argument traversals are not disjoint, the result will not respect the Traversal 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.

>>> view (partsOf (each `adjoin` _1)) ('x','y')"xyx">>> set (partsOf (each `adjoin` _1)) "abc" ('x','y')('c','b')

For the Fold version see summing.

Tag for a traversal.

Type synonym for a type-modifying van Laarhoven traversal.

Type synonym for a type-preserving van Laarhoven traversal.