Optics.Fold

Type synonym for a fold.

Obtain a Fold by lifting traverse_ like function.

foldVL . traverseOf_ ≡ id
traverseOf_ . foldVL ≡ id

Combine the results of a fold using a monoid.

Fold via embedding into a monoid.

Fold right-associatively.

Fold left-associatively, and strictly.

Fold to a list.

>>> toListOf (_1 % folded % _Right) ([Right 'h', Left 5, Right 'i'], "bye")"hi"

Evaluate each action in a structure observed by a Fold from left to right, ignoring the results.

sequenceA_ ≡ sequenceOf_ folded

>>> sequenceOf_ each (putStrLn "hello",putStrLn "world")helloworld

Traverse over all of the targets of a Fold, computing an Applicative-based answer, but unlike traverseOf do not construct a new structure. traverseOf_ generalizes traverse_ to work over any Fold.

>>> traverseOf_ each putStrLn ("hello","world")helloworld

traverse_ ≡ traverseOf_ folded

A version of traverseOf_ with the arguments flipped.

Fold via the Foldable class.

Obtain a Fold by lifting an operation that returns a Foldable result.

This can be useful to lift operations from Data.List and elsewhere into a Fold.

>>> toListOf (folding tail) [1,2,3,4][2,3,4]

Obtain a Fold by lifting foldr like function.

>>> toListOf (foldring foldr) [1,2,3,4][1,2,3,4]

Build a Fold that unfolds its values from a seed.

Prelude.unfoldr ≡ toListOf . unfolded

>>> toListOf (unfolded $ \b -> if b == 0 then Nothing else Just (b, b - 1)) 10[10,9,8,7,6,5,4,3,2,1]

Check to see if this optic matches 1 or more entries.

>>> has _Left (Left 12)True

>>> has _Right (Left 12)False

This will always return True for a Lens or Getter.

>>> has _1 ("hello","world")True

Check to see if this Fold or Traversal has no matches.

>>> hasn't _Left (Right 12)True

>>> hasn't _Left (Left 12)False

Retrieve the first entry of a Fold.

>>> headOf folded [1..10]Just 1

>>> headOf each (1,2)Just 1

Retrieve the last entry of a Fold.

>>> lastOf folded [1..10]Just 10

>>> lastOf each (1,2)Just 2

Returns True if every target of a Fold is True.

>>> andOf each (True, False)False>>> andOf each (True, True)True

and ≡ andOf folded

Returns True if any target of a Fold is True.

>>> orOf each (True, False)True>>> orOf each (False, False)False

or ≡ orOf folded

Returns True if every target of a Fold satisfies a predicate.

>>> allOf each (>=3) (4,5)True>>> allOf folded (>=2) [1..10]False

all ≡ allOf folded

Returns True if any target of a Fold satisfies a predicate.

>>> anyOf each (=='x') ('x','y')True

Returns True only if no targets of a Fold satisfy a predicate.

>>> noneOf each (not . isn't _Nothing) (Just 3, Just 4, Just 5)True>>> noneOf (folded % folded) (<10) [[13,99,20],[3,71,42]]False

Calculate the Product of every number targeted by a Fold.

>>> productOf each (4,5)20>>> productOf folded [1,2,3,4,5]120

product ≡ productOf folded

This operation may be more strict than you would expect. If you want a lazier version use \o -> getProduct . foldMapOf o Product.

Calculate the Sum of every number targeted by a Fold.

>>> sumOf each (5,6)11>>> sumOf folded [1,2,3,4]10>>> sumOf (folded % each) [(1,2),(3,4)]10

sum ≡ sumOf folded

This operation may be more strict than you would expect. If you want a lazier version use \o -> getSum . foldMapOf o Sum

The sum of a collection of actions.

>>> asumOf each ("hello","world")"helloworld"

>>> asumOf each (Nothing, Just "hello", Nothing)Just "hello"

asum ≡ asumOf folded

The sum of a collection of actions.

>>> msumOf each ("hello","world")"helloworld"

>>> msumOf each (Nothing, Just "hello", Nothing)Just "hello"

msum ≡ msumOf folded

Does the element occur anywhere within a given Fold of the structure?

>>> elemOf each "hello" ("hello","world")True

elem ≡ elemOf folded

Does the element not occur anywhere within a given Fold of the structure?

>>> notElemOf each 'd' ('a','b','c')True

>>> notElemOf each 'a' ('a','b','c')False

notElem ≡ notElemOf folded

Calculate the number of targets there are for a Fold in a given container.

Note: This can be rather inefficient for large containers and just like length, this will not terminate for infinite folds.

length ≡ lengthOf folded

>>> lengthOf _1 ("hello",())1

>>> lengthOf folded [1..10]10

>>> lengthOf (folded % folded) [[1,2],[3,4],[5,6]]6

Obtain the maximum element (if any) targeted by a Fold safely.

Note: maximumOf on a valid Iso, Lens or Getter will always return Just a value.

>>> maximumOf folded [1..10]Just 10

>>> maximumOf folded []Nothing

>>> maximumOf (folded % filtered even) [1,4,3,6,7,9,2]Just 6

maximum ≡ fromMaybe (error "empty") . maximumOf folded

In the interest of efficiency, This operation has semantics more strict than strictly necessary. \o -> getMax . foldMapOf o Max has lazier semantics but could leak memory.

Obtain the minimum element (if any) targeted by a Fold safely.

Note: minimumOf on a valid Iso, Lens or Getter will always return Just a value.

>>> minimumOf folded [1..10]Just 1

>>> minimumOf folded []Nothing

>>> minimumOf (folded % filtered even) [1,4,3,6,7,9,2]Just 2

minimum ≡ fromMaybe (error "empty") . minimumOf folded

In the interest of efficiency, This operation has semantics more strict than strictly necessary. \o -> getMin . foldMapOf o Min has lazier semantics but could leak memory.

Obtain the maximum element (if any) targeted by a Fold according to a user supplied Ordering.

>>> maximumByOf folded (compare `on` length) ["mustard","relish","ham"]Just "mustard"

In the interest of efficiency, This operation has semantics more strict than strictly necessary.

maximumBy cmp ≡ fromMaybe (error "empty") . maximumByOf folded cmp

Obtain the minimum element (if any) targeted by a Fold according to a user supplied Ordering.

In the interest of efficiency, This operation has semantics more strict than strictly necessary.

>>> minimumByOf folded (compare `on` length) ["mustard","relish","ham"]Just "ham"

minimumBy cmp ≡ fromMaybe (error "empty") . minimumByOf folded cmp

The findOf function takes a Fold, a predicate and a structure and returns the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

>>> findOf each even (1,3,4,6)Just 4

>>> findOf folded even [1,3,5,7]Nothing

find ≡ findOf folded

The findMOf function takes a Fold, a monadic predicate and a structure and returns in the monad the leftmost element of the structure matching the predicate, or Nothing if there is no such element.

>>> findMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,4,6)"Checking 1""Checking 3""Checking 4"Just 4

>>> findMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,5,7)"Checking 1""Checking 3""Checking 5""Checking 7"Nothing

findMOf folded :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m (Maybe a)

The lookupOf function takes a Fold, a key, and a structure containing key/value pairs. It returns the first value corresponding to the given key. This function generalizes lookup to work on an arbitrary Fold instead of lists.

>>> lookupOf folded 4 [(2, 'a'), (4, 'b'), (4, 'c')]Just 'b'

>>> lookupOf folded 2 [(2, 'a'), (4, 'b'), (4, 'c')]Just 'a'

Given a Fold that knows how to locate immediate children, retrieve all of the transitive descendants of a node, including itself.

Given a Fold that knows how to locate immediate children, fold all of the transitive descendants of a node, including itself.

Perform a fold-like computation on each value, technically a paramorphism.

Convert a fold to an AffineFold that visits the first element of the original fold.

For the traversal version see singular.

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

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

>>> toListOf (_1 % ix 0 `summing` _2 % ix 1) ([1,2], [4,7,1])[1,7]

For the traversal version see adjoin.

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

>>> toListOf (ix 1 `failing` ix 0) [4,7][7]>>> toListOf (ix 1 `failing` ix 0) [4][4]

Tag for a fold.