Control.Lens.Fold

A Fold a c is a generalization of something Foldable. It allows you to extract multiple results from a container. A Foldable container can be characterized by the behavior of foldMap :: (Foldable t, Monoid m) => (c -> m) -> t c -> m. Since we want to be able to work with monomorphic containers, we could generalize this signature to forall m. Monoid m => (c -> m) -> a -> m, and then decorate it with Accessor to obtain

type Fold a c = forall m. Monoid m => Getting m a a c c

Every Getter is a valid Fold that simply doesn't use the Monoid it is passed.

In practice the type we use is slightly more complicated to allow for better error messages and for it to be transformed by certain Applicative transformers.

Everything you can do with a Foldable container, you can with with a Fold and there are combinators that generalize the usual Foldable operations here.

Folds

type Fold a c = forall f. (Gettable f, Applicative f) => (c -> f c) -> a -> f a

A Fold describes how to retrieve multiple values in a way that can be composed with other lens-like constructions.

A Fold a c provides a structure with operations very similar to those of the Foldable typeclass, see foldMapOf and the other Fold combinators.

By convention, if there exists a foo method that expects a Foldable (f c), then there should be a fooOf method that takes a Fold a c and a value of type a.

A Getter is a legal Fold that just ignores the supplied Monoid

Unlike a Traversal a Fold is read-only. Since a Fold cannot be used to write back there are no lens laws that apply.

(^?) :: a -> Getting (First c) a b c d -> Maybe c

Perform a safe head of a Fold or Traversal or retrieve Just the result from a Getter or Lens.

When using a Traversal as a partial Lens, or a Fold as a partial Getter this can be a convenient way to extract the optional value.

(^?) ≡ flip headOf

 (^?) :: a -> Getter a c           -> Maybe c
 (^?) :: a -> Fold a c             -> Maybe c
 (^?) :: a -> Simple Lens a c      -> Maybe c
 (^?) :: a -> Simple Iso a c       -> Maybe c
 (^?) :: a -> Simple Traversal a c -> Maybe c

(^..) :: a -> Getting [c] a b c d -> [c]

A convenient infix (flipped) version of toListOf.

>>> import Control.Lens
>>> [[1,2],[3]]^..traverse.traverse
[1,2,3]

>>> (1,2)^..both
[1,2]

 toList xs ≡ xs ^.. folded
 (^..) ≡ flip toListOf

 (^..) :: a -> Getter a c           -> [c]
 (^..) :: a -> Fold a c             -> [c]
 (^..) :: a -> Simple Lens a c      -> [c]
 (^..) :: a -> Simple Iso a c       -> [c]
 (^..) :: a -> Simple Traversal a c -> [c]

Building Folds

folding :: (Foldable f, Applicative g, Gettable g) => (a -> f c) -> LensLike g a b c d

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.

folded :: Foldable f => Fold (f c) c

Obtain a Fold from any Foldable.

unfolded :: (b -> Maybe (a, b)) -> Fold b a

Build a fold that unfolds its values from a seed.

unfoldr ≡ toListOf . unfolded

iterated :: (a -> a) -> Fold a a

x ^. iterated f Return an infinite fold of repeated applications of f to x.

toListOf (iterated f) a ≡ iterate f a

filtered :: (Gettable f, Applicative f) => (c -> Bool) -> LensLike f a b c d -> LensLike f a b c d

Obtain a Fold by filtering a Lens, Iso, Getter, Fold or Traversal.

backwards :: LensLike (Backwards f) a b c d -> LensLike f a b c d

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

Note: backwards should have no impact on a Getter Setter, Lens or Iso.

To change the direction of an Iso, use from.

repeated :: Fold a a

Fold by repeating the input forever.

repeat ≡ toListOf repeated

replicated :: Int -> Fold a a

A fold that replicates its input n times.

replicate n ≡ toListOf (replicated n)

cycled :: (Applicative f, Gettable f) => LensLike f a b c d -> LensLike f a b c d

Transform a fold into a fold that loops over its elements over and over.

>>> import Control.Lens
>>> take 6 $ toListOf (cycled traverse) [1,2,3]
[1,2,3,1,2,3]

takingWhile :: (Gettable f, Applicative f) => (c -> Bool) -> Getting (Endo (f a)) a a c c -> LensLike f a a c c

Obtain a Fold by taking elements from another Fold, Lens, Iso, Getter or Traversal while a predicate holds.

takeWhile p ≡ toListOf (takingWhile p folded)

>>> toListOf (takingWhile (<=3) folded) [1..]
[1,2,3]

droppingWhile :: (Gettable f, Applicative f) => (c -> Bool) -> Getting (Endo (f a)) a a c c -> LensLike f a a c c

Obtain a Fold by dropping elements from another Fold, Lens, Iso, Getter or Traversal while a predicate holds.

dropWhile p ≡ toListOf (droppingWhile p folded)

>>> toListOf (droppingWhile (<=3) folded) [1..6]
[4,5,6]

Folding

foldMapOf :: Getting r a b c d -> (c -> r) -> a -> r

foldMap = foldMapOf folded

foldMapOf ≡ views

 foldMapOf ::             Getter a c           -> (c -> r) -> a -> r
 foldMapOf :: Monoid r => Fold a c             -> (c -> r) -> a -> r
 foldMapOf ::             Simple Lens a c      -> (c -> r) -> a -> r
 foldMapOf ::             Simple Iso a c       -> (c -> r) -> a -> r
 foldMapOf :: Monoid r => Simple Traversal a c -> (c -> r) -> a -> r

foldOf :: Getting c a b c d -> a -> c

fold = foldOf folded

foldOf ≡ view

 foldOf ::             Getter a m           -> a -> m
 foldOf :: Monoid m => Fold a m             -> a -> m
 foldOf ::             Simple Lens a m      -> a -> m
 foldOf ::             Simple Iso a m       -> a -> m
 foldOf :: Monoid m => Simple Traversal a m -> a -> m

foldrOf :: Getting (Endo e) a b c d -> (c -> e -> e) -> e -> a -> e

Right-associative fold of parts of a structure that are viewed through a Lens, Getter, Fold or Traversal.

foldr ≡ foldrOf folded

 foldrOf :: Getter a c           -> (c -> e -> e) -> e -> a -> e
 foldrOf :: Fold a c             -> (c -> e -> e) -> e -> a -> e
 foldrOf :: Simple Lens a c      -> (c -> e -> e) -> e -> a -> e
 foldrOf :: Simple Iso a c       -> (c -> e -> e) -> e -> a -> e
 foldrOf :: Simple Traversal a c -> (c -> e -> e) -> e -> a -> e

foldlOf :: Getting (Dual (Endo e)) a b c d -> (e -> c -> e) -> e -> a -> e

Left-associative fold of the parts of a structure that are viewed through a Lens, Getter, Fold or Traversal.

foldl ≡ foldlOf folded

 foldlOf :: Getter a c           -> (e -> c -> e) -> e -> a -> e
 foldlOf :: Fold a c             -> (e -> c -> e) -> e -> a -> e
 foldlOf :: Simple Lens a c      -> (e -> c -> e) -> e -> a -> e
 foldlOf :: Simple Iso a c       -> (e -> c -> e) -> e -> a -> e
 foldlOf :: Simple Traversal a c -> (e -> c -> e) -> e -> a -> e

toListOf :: Getting [c] a b c d -> a -> [c]

Extract a list of the targets of a Fold. See also (^..).

 toList ≡ toListOf folded
 (^..) ≡ flip toListOf

anyOf :: Getting Any a b c d -> (c -> Bool) -> a -> Bool

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

>>> import Control.Lens
>>> anyOf both (=='x') ('x','y')
True
>>> import Data.Data.Lens
>>> anyOf biplate (== "world") (((),2::Int),"hello",("world",11))
True

any ≡ anyOf folded

 anyOf :: Getter a c               -> (c -> Bool) -> a -> Bool
 anyOf :: Fold a c                 -> (c -> Bool) -> a -> Bool
 anyOf :: Simple Lens a b c d      -> (c -> Bool) -> a -> Bool
 anyOf :: Simple Iso a b c d       -> (c -> Bool) -> a -> Bool
 anyOf :: Simple Traversal a b c d -> (c -> Bool) -> a -> Bool

allOf :: Getting All a b c d -> (c -> Bool) -> a -> Bool

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

>>> import Control.Lens
>>> allOf both (>=3) (4,5)
True
>>> allOf folded (>=2) [1..10]
False

all ≡ allOf folded

 allOf :: Getter a c           -> (c -> Bool) -> a -> Bool
 allOf :: Fold a c             -> (c -> Bool) -> a -> Bool
 allOf :: Simple Lens a c      -> (c -> Bool) -> a -> Bool
 allOf :: Simple Iso a c       -> (c -> Bool) -> a -> Bool
 allOf :: Simple Traversal a c -> (c -> Bool) -> a -> Bool

andOf :: Getting All a b Bool d -> a -> Bool

Returns True if every target of a Fold is True.

>>> import Control.Lens
>>> andOf both (True,False)
False
>>> andOf both (True,True)
True

and ≡ andOf folded

 andOf :: Getter a Bool           -> a -> Bool
 andOf :: Fold a Bool             -> a -> Bool
 andOf :: Simple Lens a Bool      -> a -> Bool
 andOf :: Simple Iso a Bool       -> a -> Bool
 andOf :: Simple Traversal a Bool -> a -> Bool

orOf :: Getting Any a b Bool d -> a -> Bool

Returns True if any target of a Fold is True.

>>> import Control.Lens
>>> orOf both (True,False)
True
>>> orOf both (False,False)
False

or ≡ orOf folded

 orOf :: Getter a Bool           -> a -> Bool
 orOf :: Fold a Bool             -> a -> Bool
 orOf :: Simple Lens a Bool      -> a -> Bool
 orOf :: Simple Iso a Bool       -> a -> Bool
 orOf :: Simple Traversal a Bool -> a -> Bool

productOf :: Getting (Product c) a b c d -> a -> c

Calculate the product of every number targeted by a Fold

>>> import Control.Lens
>>> productOf both (4,5)
20
>>> productOf folded [1,2,3,4,5]
120

product ≡ productOf folded

 productOf ::          Getter a c           -> a -> c
 productOf :: Num c => Fold a c             -> a -> c
 productOf ::          Simple Lens a c      -> a -> c
 productOf ::          Simple Iso a c       -> a -> c
 productOf :: Num c => Simple Traversal a c -> a -> c

sumOf :: Getting (Sum c) a b c d -> a -> c

Calculate the sum of every number targeted by a Fold.

>>> import Control.Lens
>>> sumOf both (5,6)
11
>>> sumOf folded [1,2,3,4]
10
>>> sumOf (folded.both) [(1,2),(3,4)]
10
>>> import Data.Data.Lens
>>> sumOf biplate [(1::Int,[]),(2,[(3::Int,4::Int)])] :: Int
10

sum ≡ sumOf folded

 sumOf _1 :: (a, b) -> a
 sumOf (folded . _1) :: (Foldable f, Num a) => f (a, b) -> a

 sumOf ::          Getter a c           -> a -> c
 sumOf :: Num c => Fold a c             -> a -> c
 sumOf ::          Simple Lens a c      -> a -> c
 sumOf ::          Simple Iso a c       -> a -> c
 sumOf :: Num c => Simple Traversal a c -> a -> c

traverseOf_ :: Functor f => Getting (Traversed f) a b c d -> (c -> f e) -> a -> f ()

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

When passed a Getter, traverseOf_ can work over any Functor, but when passed a Fold, traverseOf_ requires an Applicative.

>>> import Control.Lens
>>> traverseOf_ both putStrLn ("hello","world")
hello
world

traverse_ ≡ traverseOf_ folded

 traverseOf_ _2 :: Functor f => (c -> f e) -> (c1, c) -> f ()
 traverseOf_ traverseLeft :: Applicative f => (a -> f b) -> Either a c -> f ()

The rather specific signature of traverseOf_ allows it to be used as if the signature was any of:

 traverseOf_ :: Functor f     => Getter a c           -> (c -> f e) -> a -> f ()
 traverseOf_ :: Applicative f => Fold a c             -> (c -> f e) -> a -> f ()
 traverseOf_ :: Functor f     => Simple Lens a c      -> (c -> f e) -> a -> f ()
 traverseOf_ :: Functor f     => Simple Iso a c       -> (c -> f e) -> a -> f ()
 traverseOf_ :: Applicative f => Simple Traversal a c -> (c -> f e) -> a -> f ()

forOf_ :: Functor f => Getting (Traversed f) a b c d -> a -> (c -> f e) -> f ()

Traverse over all of the targets of a Fold (or Getter), computing an Applicative (or Functor) -based answer, but unlike forOf do not construct a new structure. forOf_ generalizes for_ to work over any Fold.

When passed a Getter, forOf_ can work over any Functor, but when passed a Fold, forOf_ requires an Applicative.

for_ ≡ forOf_ folded

The rather specific signature of forOf_ allows it to be used as if the signature was any of:

 forOf_ :: Functor f     => Getter a c           -> a -> (c -> f e) -> f ()
 forOf_ :: Applicative f => Fold a c             -> a -> (c -> f e) -> f ()
 forOf_ :: Functor f     => Simple Lens a c      -> a -> (c -> f e) -> f ()
 forOf_ :: Functor f     => Simple Iso a c       -> a -> (c -> f e) -> f ()
 forOf_ :: Applicative f => Simple Traversal a c -> a -> (c -> f e) -> f ()

sequenceAOf_ :: Functor f => Getting (Traversed f) a b (f ()) d -> a -> f ()

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

sequenceA_ ≡ sequenceAOf_ folded

 sequenceAOf_ :: Functor f     => Getter a (f ())           -> a -> f ()
 sequenceAOf_ :: Applicative f => Fold a (f ())             -> a -> f ()
 sequenceAOf_ :: Functor f     => Simple Lens a (f ())      -> a -> f ()
 sequenceAOf_ :: Functor f     => Simple Iso a (f ())       -> a -> f ()
 sequenceAOf_ :: Applicative f => Simple Traversal a (f ()) -> a -> f ()

mapMOf_ :: Monad m => Getting (Sequenced m) a b c d -> (c -> m e) -> a -> m ()

Map each target of a Fold on a structure to a monadic action, evaluate these actions from left to right, and ignore the results.

mapM_ ≡ mapMOf_ folded

 mapMOf_ :: Monad m => Getter a c           -> (c -> m e) -> a -> m ()
 mapMOf_ :: Monad m => Fold a c             -> (c -> m e) -> a -> m ()
 mapMOf_ :: Monad m => Simple Lens a c      -> (c -> m e) -> a -> m ()
 mapMOf_ :: Monad m => Simple Iso a c       -> (c -> m e) -> a -> m ()
 mapMOf_ :: Monad m => Simple Traversal a c -> (c -> m e) -> a -> m ()

forMOf_ :: Monad m => Getting (Sequenced m) a b c d -> a -> (c -> m e) -> m ()

forMOf_ is mapMOf_ with two of its arguments flipped.

forM_ ≡ forMOf_ folded

 forMOf_ :: Monad m => Getter a c           -> a -> (c -> m e) -> m ()
 forMOf_ :: Monad m => Fold a c             -> a -> (c -> m e) -> m ()
 forMOf_ :: Monad m => Simple Lens a c      -> a -> (c -> m e) -> m ()
 forMOf_ :: Monad m => Simple Iso a c       -> a -> (c -> m e) -> m ()
 forMOf_ :: Monad m => Simple Traversal a c -> a -> (c -> m e) -> m ()

sequenceOf_ :: Monad m => Getting (Sequenced m) a b (m c) d -> a -> m ()

Evaluate each monadic action referenced by a Fold on the structure from left to right, and ignore the results.

sequence_ ≡ sequenceOf_ folded

 sequenceOf_ :: Monad m => Getter a (m b)           -> a -> m ()
 sequenceOf_ :: Monad m => Fold a (m b)             -> a -> m ()
 sequenceOf_ :: Monad m => Simple Lens a (m b)      -> a -> m ()
 sequenceOf_ :: Monad m => Simple Iso a (m b)       -> a -> m ()
 sequenceOf_ :: Monad m => Simple Traversal a (m b) -> a -> m ()

asumOf :: Alternative f => Getting (Endo (f c)) a b (f c) d -> a -> f c

The sum of a collection of actions, generalizing concatOf.

asum ≡ asumOf folded

 asumOf :: Alternative f => Getter a c           -> a -> f c
 asumOf :: Alternative f => Fold a c             -> a -> f c
 asumOf :: Alternative f => Simple Lens a c      -> a -> f c
 asumOf :: Alternative f => Simple Iso a c       -> a -> f c
 asumOf :: Alternative f => Simple Traversal a c -> a -> f c

msumOf :: MonadPlus m => Getting (Endo (m c)) a b (m c) d -> a -> m c

The sum of a collection of actions, generalizing concatOf.

msum ≡ msumOf folded

 msumOf :: MonadPlus m => Getter a c           -> a -> m c
 msumOf :: MonadPlus m => Fold a c             -> a -> m c
 msumOf :: MonadPlus m => Simple Lens a c      -> a -> m c
 msumOf :: MonadPlus m => Simple Iso a c       -> a -> m c
 msumOf :: MonadPlus m => Simple Traversal a c -> a -> m c

concatMapOf :: Getting [e] a b c d -> (c -> [e]) -> a -> [e]

Map a function over all the targets of a Fold of a container and concatenate the resulting lists.

concatMap ≡ concatMapOf folded

 concatMapOf :: Getter a c           -> (c -> [e]) -> a -> [e]
 concatMapOf :: Fold a c             -> (c -> [e]) -> a -> [e]
 concatMapOf :: Simple Lens a c      -> (c -> [e]) -> a -> [e]
 concatMapOf :: Simple Iso a c       -> (c -> [e]) -> a -> [e]
 concatMapOf :: Simple Traversal a c -> (c -> [e]) -> a -> [e]

concatOf :: Getting [e] a b [e] d -> a -> [e]

Concatenate all of the lists targeted by a Fold into a longer list.

>>> import Control.Lens
>>> concatOf both ("pan","ama")
"panama"

 concat ≡ concatOf folded
 concatOf ≡ view

 concatOf :: Getter a [e]           -> a -> [e]
 concatOf :: Fold a [e]             -> a -> [e]
 concatOf :: Simple Iso a [e]       -> a -> [e]
 concatOf :: Simple Lens a [e]      -> a -> [e]
 concatOf :: Simple Traversal a [e] -> a -> [e]

elemOf :: Eq c => Getting Any a b c d -> c -> a -> Bool

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

>>> import Control.Lens
>>> elemOf both "hello" ("hello","world")
True

elem ≡ elemOf folded

 elemOf :: Eq c => Getter a c           -> c -> a -> Bool
 elemOf :: Eq c => Fold a c             -> c -> a -> Bool
 elemOf :: Eq c => Simple Lens a c      -> c -> a -> Bool
 elemOf :: Eq c => Simple Iso a c       -> c -> a -> Bool
 elemOf :: Eq c => Simple Traversal a c -> c -> a -> Bool

notElemOf :: Eq c => Getting All a b c d -> c -> a -> Bool

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

notElem ≡ notElemOf folded

 notElemOf :: Eq c => Getter a c           -> c -> a -> Bool
 notElemOf :: Eq c => Fold a c             -> c -> a -> Bool
 notElemOf :: Eq c => Simple Iso a c       -> c -> a -> Bool
 notElemOf :: Eq c => Simple Lens a c      -> c -> a -> Bool
 notElemOf :: Eq c => Simple Traversal a c -> c -> a -> Bool

lengthOf :: Getting (Sum Int) a b c d -> a -> Int

Note: this can be rather inefficient for large containers.

length ≡ lengthOf folded

>>> import Control.Lens
>>> lengthOf _1 ("hello",())
1

lengthOf (folded . folded) :: Foldable f => f (g a) -> Int

 lengthOf :: Getter a c           -> a -> Int
 lengthOf :: Fold a c             -> a -> Int
 lengthOf :: Simple Lens a c      -> a -> Int
 lengthOf :: Simple Iso a c       -> a -> Int
 lengthOf :: Simple Traversal a c -> a -> Int

nullOf :: Getting All a b c d -> a -> Bool

Returns True if this Fold or Traversal has no targets in the given container.

Note: nullOf on a valid Iso, Lens or Getter should always return False

null ≡ nullOf folded

This may be rather inefficient compared to the null check of many containers.

>>> import Control.Lens
>>> nullOf _1 (1,2)
False

nullOf (folded . _1 . folded) :: Foldable f => f (g a, b) -> Bool

 nullOf :: Getter a c           -> a -> Bool
 nullOf :: Fold a c             -> a -> Bool
 nullOf :: Simple Iso a c       -> a -> Bool
 nullOf :: Simple Lens a c      -> a -> Bool
 nullOf :: Simple Traversal a c -> a -> Bool

headOf :: Getting (First c) a b c d -> a -> Maybe c

Perform a safe head of a Fold or Traversal or retrieve Just the result from a Getter or Lens. See also (^?).

listToMaybe . toList ≡ headOf folded

 headOf :: Getter a c           -> a -> Maybe c
 headOf :: Fold a c             -> a -> Maybe c
 headOf :: Simple Lens a c      -> a -> Maybe c
 headOf :: Simple Iso a c       -> a -> Maybe c
 headOf :: Simple Traversal a c -> a -> Maybe c

lastOf :: Getting (Last c) a b c d -> a -> Maybe c

Perform a safe last of a Fold or Traversal or retrieve Just the result from a Getter or Lens.

 lastOf :: Getter a c           -> a -> Maybe c
 lastOf :: Fold a c             -> a -> Maybe c
 lastOf :: Simple Lens a c      -> a -> Maybe c
 lastOf :: Simple Iso a c       -> a -> Maybe c
 lastOf :: Simple Traversal a c -> a -> Maybe c

maximumOf :: Getting (Max c) a b c d -> a -> Maybe c

Obtain the maximum element (if any) targeted by a Fold or Traversal

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

maximum ≡ fromMaybe (error empty) . maximumOf folded

 maximumOf ::          Getter a c           -> a -> Maybe c
 maximumOf :: Ord c => Fold a c             -> a -> Maybe c
 maximumOf ::          Simple Iso a c       -> a -> Maybe c
 maximumOf ::          Simple Lens a c      -> a -> Maybe c
 maximumOf :: Ord c => Simple Traversal a c -> a -> Maybe c

minimumOf :: Getting (Min c) a b c d -> a -> Maybe c

Obtain the minimum element (if any) targeted by a Fold or Traversal

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

minimum ≡ fromMaybe (error empty) . minimumOf folded

 minimumOf ::          Getter a c           -> a -> Maybe c
 minimumOf :: Ord c => Fold a c             -> a -> Maybe c
 minimumOf ::          Simple Iso a c       -> a -> Maybe c
 minimumOf ::          Simple Lens a c      -> a -> Maybe c
 minimumOf :: Ord c => Simple Traversal a c -> a -> Maybe c

maximumByOf :: Getting (Endo (Maybe c)) a b c d -> (c -> c -> Ordering) -> a -> Maybe c

Obtain the maximum element (if any) targeted by a Fold, Traversal, Lens, Iso, or Getter according to a user supplied ordering.

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

 maximumByOf :: Getter a c           -> (c -> c -> Ordering) -> a -> Maybe c
 maximumByOf :: Fold a c             -> (c -> c -> Ordering) -> a -> Maybe c
 maximumByOf :: Simple Iso a c       -> (c -> c -> Ordering) -> a -> Maybe c
 maximumByOf :: Simple Lens a c      -> (c -> c -> Ordering) -> a -> Maybe c
 maximumByOf :: Simple Traversal a c -> (c -> c -> Ordering) -> a -> Maybe c

minimumByOf :: Getting (Endo (Maybe c)) a b c d -> (c -> c -> Ordering) -> a -> Maybe c

Obtain the minimum element (if any) targeted by a Fold, Traversal, Lens, Iso or Getter according to a user supplied ordering.

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

 minimumByOf :: Getter a c           -> (c -> c -> Ordering) -> a -> Maybe c
 minimumByOf :: Fold a c             -> (c -> c -> Ordering) -> a -> Maybe c
 minimumByOf :: Simple Iso a c       -> (c -> c -> Ordering) -> a -> Maybe c
 minimumByOf :: Simple Lens a c      -> (c -> c -> Ordering) -> a -> Maybe c
 minimumByOf :: Simple Traversal a c -> (c -> c -> Ordering) -> a -> Maybe c

findOf :: Getting (First c) a b c d -> (c -> Bool) -> a -> Maybe c

The findOf function takes a Lens (or Getter, Iso, Fold, or Traversal), 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 :: Getter a c           -> (c -> Bool) -> a -> Maybe c
 findOf :: Fold a c             -> (c -> Bool) -> a -> Maybe c
 findOf :: Simple Iso a c       -> (c -> Bool) -> a -> Maybe c
 findOf :: Simple Lens a c      -> (c -> Bool) -> a -> Maybe c
 findOf :: Simple Traversal a c -> (c -> Bool) -> a -> Maybe c

foldrOf' :: Getting (Dual (Endo (e -> e))) a b c d -> (c -> e -> e) -> e -> a -> e

Strictly fold right over the elements of a structure.

foldr' ≡ foldrOf' folded

 foldrOf' :: Getter a c           -> (c -> e -> e) -> e -> a -> e
 foldrOf' :: Fold a c             -> (c -> e -> e) -> e -> a -> e
 foldrOf' :: Simple Iso a c       -> (c -> e -> e) -> e -> a -> e
 foldrOf' :: Simple Lens a c      -> (c -> e -> e) -> e -> a -> e
 foldrOf' :: Simple Traversal a c -> (c -> e -> e) -> e -> a -> e

foldlOf' :: Getting (Endo (e -> e)) a b c d -> (e -> c -> e) -> e -> a -> e

Fold over the elements of a structure, associating to the left, but strictly.

foldl' ≡ foldlOf' folded

 foldlOf' :: Getter a c           -> (e -> c -> e) -> e -> a -> e
 foldlOf' :: Fold a c             -> (e -> c -> e) -> e -> a -> e
 foldlOf' :: Simple Iso a c       -> (e -> c -> e) -> e -> a -> e
 foldlOf' :: Simple Lens a c      -> (e -> c -> e) -> e -> a -> e
 foldlOf' :: Simple Traversal a c -> (e -> c -> e) -> e -> a -> e

foldr1Of :: Getting (Endo (Maybe c)) a b c d -> (c -> c -> c) -> a -> c

A variant of foldrOf that has no base case and thus may only be applied to lenses and structures such that the lens views at least one element of the structure.

 foldr1Of l f ≡ foldr1 f . toListOf l
 foldr1 ≡ foldr1Of folded

 foldr1Of :: Getter a c           -> (c -> c -> c) -> a -> c
 foldr1Of :: Fold a c             -> (c -> c -> c) -> a -> c
 foldr1Of :: Simple Iso a c       -> (c -> c -> c) -> a -> c
 foldr1Of :: Simple Lens a c      -> (c -> c -> c) -> a -> c
 foldr1Of :: Simple Traversal a c -> (c -> c -> c) -> a -> c

foldl1Of :: Getting (Dual (Endo (Maybe c))) a b c d -> (c -> c -> c) -> a -> c

A variant of foldlOf that has no base case and thus may only be applied to lenses and strutures such that the lens views at least one element of the structure.

 foldl1Of l f ≡ foldl1Of l f . toList
 foldl1 ≡ foldl1Of folded

 foldl1Of :: Getter a c           -> (c -> c -> c) -> a -> c
 foldl1Of :: Fold a c             -> (c -> c -> c) -> a -> c
 foldl1Of :: Simple Iso a c       -> (c -> c -> c) -> a -> c
 foldl1Of :: Simple Lens a c      -> (c -> c -> c) -> a -> c
 foldl1Of :: Simple Traversal a c -> (c -> c -> c) -> a -> c

foldrMOf :: Monad m => Getting (Dual (Endo (e -> m e))) a b c d -> (c -> e -> m e) -> e -> a -> m e

Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.

foldrM ≡ foldrMOf folded

 foldrMOf :: Monad m => Getter a c           -> (c -> e -> m e) -> e -> a -> m e
 foldrMOf :: Monad m => Fold a c             -> (c -> e -> m e) -> e -> a -> m e
 foldrMOf :: Monad m => Simple Iso a c       -> (c -> e -> m e) -> e -> a -> m e
 foldrMOf :: Monad m => Simple Lens a c      -> (c -> e -> m e) -> e -> a -> m e
 foldrMOf :: Monad m => Simple Traversal a c -> (c -> e -> m e) -> e -> a -> m e

foldlMOf :: Monad m => Getting (Endo (e -> m e)) a b c d -> (e -> c -> m e) -> e -> a -> m e

Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.

foldlM ≡ foldlMOf folded

 foldlMOf :: Monad m => Getter a c           -> (e -> c -> m e) -> e -> a -> m e
 foldlMOf :: Monad m => Fold a c             -> (e -> c -> m e) -> e -> a -> m e
 foldlMOf :: Monad m => Simple Iso a c       -> (e -> c -> m e) -> e -> a -> m e
 foldlMOf :: Monad m => Simple Lens a c      -> (e -> c -> m e) -> e -> a -> m e
 foldlMOf :: Monad m => Simple Traversal a c -> (e -> c -> m e) -> e -> a -> m e

Storing Folds

newtype ReifiedFold a c

Useful for storing folds in containers.

Constructors

ReifyFold

Fields

reflectFold :: Fold a c