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"

Since: 0.4

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 mapAccumR to an arbitrary Traversal.

mapAccumR ≡ mapAccumROf traversed

mapAccumROf accumulates State from right to left.

This generalizes mapAccumL to an arbitrary Traversal.

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.

Since: 0.4.1

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

Since: 0.4.1

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"

Since: 0.3

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.

Since: 0.4

Tag for a traversal.

Type synonym for a type-modifying van Laarhoven traversal.

Type synonym for a type-preserving van Laarhoven traversal.