    {-# LANGUAGE CPP #-}
    {-# LANGUAGE Rank2Types #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE ConstraintKinds #-}
    {-# LANGUAGE Trustworthy #-}

    #include "lens-common.h"
    {-# OPTIONS_GHC -Wno-orphans #-}
    ----------------------------------------------------------------------------
    -- |
    -- Module      :  Control.Lens.Fold
    -- Copyright   :  (C) 2012-16 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  provisional
    -- Portability :  Rank2Types
    --
    -- A @'Fold' s a@ 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
    -- @'Data.Foldable.foldMap' :: ('Foldable' t, 'Monoid' m) => (a -> m) -> t a -> m@.
    -- Since we want to be able to work with monomorphic containers, we could
    -- generalize this signature to @forall m. 'Monoid' m => (a -> m) -> s -> m@,
    -- and then decorate it with 'Const' to obtain
    --
    -- @type 'Fold' s a = forall m. 'Monoid' m => 'Getting' m s a@
    --
    -- 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.
    ----------------------------------------------------------------------------
    module Control.Lens.Fold
      (
      -- * Folds
        Fold
      , IndexedFold

      -- * Getting Started
      , (^..)
      , (^?)
      , (^?!)
      , pre, ipre
      , preview, previews, ipreview, ipreviews
      , preuse, preuses, ipreuse, ipreuses

      , has, hasn't

      -- ** Building Folds
      , folding, ifolding
      , foldring, ifoldring
      , folded
      , folded64
      , unfolded
      , iterated
      , filtered
      , filteredBy
      , backwards
      , repeated
      , replicated
      , cycled
      , takingWhile
      , droppingWhile
      , worded, lined

      -- ** Folding
      , foldMapOf, foldOf
      , foldrOf, foldlOf
      , toListOf, toNonEmptyOf
      , altOf
      , anyOf, allOf, noneOf
      , andOf, orOf
      , productOf, sumOf
      , traverseOf_, forOf_, sequenceAOf_
      , traverse1Of_, for1Of_, sequence1Of_
      , mapMOf_, forMOf_, sequenceOf_
      , asumOf, msumOf
      , concatMapOf, concatOf
      , elemOf, notElemOf
      , lengthOf
      , nullOf, notNullOf
      , firstOf, first1Of, lastOf, last1Of
      , maximumOf, maximum1Of, minimumOf, minimum1Of
      , maximumByOf, minimumByOf
      , findOf
      , findMOf
      , foldrOf', foldlOf'
      , foldr1Of, foldl1Of
      , foldr1Of', foldl1Of'
      , foldrMOf, foldlMOf
      , lookupOf

      -- * Indexed Folds
      , (^@..)
      , (^@?)
      , (^@?!)

      -- ** Indexed Folding
      , ifoldMapOf
      , ifoldrOf
      , ifoldlOf
      , ianyOf
      , iallOf
      , inoneOf
      , itraverseOf_
      , iforOf_
      , imapMOf_
      , iforMOf_
      , iconcatMapOf
      , ifindOf
      , ifindMOf
      , ifoldrOf'
      , ifoldlOf'
      , ifoldrMOf
      , ifoldlMOf
      , itoListOf
      , elemIndexOf
      , elemIndicesOf
      , findIndexOf
      , findIndicesOf

      -- ** Building Indexed Folds
      , ifiltered
      , itakingWhile
      , idroppingWhile

      -- * Internal types
      , Leftmost
      , Rightmost
      , Traversed
      , Sequenced

      -- * Fold with Reified Monoid
      , foldBy
      , foldByOf
      , foldMapBy
      , foldMapByOf
      ) where

    import Prelude ()

    import Control.Applicative.Backwards
    import Control.Comonad
    import Control.Lens.Getter
    import Control.Lens.Internal.Fold
    import Control.Lens.Internal.Getter
    import Control.Lens.Internal.Indexed
    import Control.Lens.Internal.Magma
    import Control.Lens.Internal.Prelude
    import Control.Lens.Type
    import Control.Monad as Monad
    import Control.Monad.Reader
    import Control.Monad.State
    import Data.CallStack
    import Data.Functor.Apply hiding ((<.))
    import Data.Int (Int64)
    import Data.List (intercalate)
    import Data.Maybe (fromMaybe)
    import Data.Monoid (First (..), All (..), Alt (..), Any (..))
    import Data.Reflection

    import qualified Data.Semigroup as Semi

    -- $setup
    -- >>> :set -XNoOverloadedStrings
    -- >>> import Control.Lens
    -- >>> import Control.Lens.Extras (is)
    -- >>> import Data.Function
    -- >>> import Data.List.Lens
    -- >>> import Data.List.NonEmpty (NonEmpty (..))
    -- >>> import Debug.SimpleReflect.Expr
    -- >>> import Debug.SimpleReflect.Vars as Vars hiding (f,g)
    -- >>> import Control.DeepSeq (NFData (..), force)
    -- >>> import Control.Exception (evaluate)
    -- >>> import Data.Maybe (fromMaybe)
    -- >>> import Data.Monoid (Sum (..))
    -- >>> import System.Timeout (timeout)
    -- >>> import qualified Data.Map as Map
    -- >>> let f :: Expr -> Expr; f = Debug.SimpleReflect.Vars.f
    -- >>> let g :: Expr -> Expr; g = Debug.SimpleReflect.Vars.g
    -- >>> let timingOut :: NFData a => a -> IO a; timingOut = fmap (fromMaybe (error "timeout")) . timeout (5*10^6) . evaluate . force

    infixl 8 ^.., ^?, ^?!, ^@.., ^@?, ^@?!

    --------------------------
    -- Folds
    --------------------------

    -- | 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'.
    --
    -- >>> [1,2,3,4]^..folding reverse
    -- [4,3,2,1]
    folding :: Foldable f => (s -> f a) -> Fold s a
    folding :: forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding s -> f a
    sfa a -> f a
    agb = f () -> f s
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f () -> f s) -> (s -> f ()) -> s -> f s
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> f a) -> f a -> f ()
    forall (t :: * -> *) (f :: * -> *) a b.
    (Foldable t, Applicative f) =>
    (a -> f b) -> t a -> f ()
    traverse_ a -> f a
    agb (f a -> f ()) -> (s -> f a) -> s -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . s -> f a
    sfa
    {-# INLINE folding #-}

    ifolding :: (Foldable f, Indexable i p, Contravariant g, Applicative g) => (s -> f (i, a)) -> Over p g s t a b
    ifolding :: forall (f :: * -> *) i (p :: * -> * -> *) (g :: * -> *) s a t b.
    (Foldable f, Indexable i p, Contravariant g, Applicative g) =>
    (s -> f (i, a)) -> Over p g s t a b
    ifolding s -> f (i, a)
    sfa p a (g b)
    f = g () -> g t
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (g () -> g t) -> (s -> g ()) -> s -> g t
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((i, a) -> g (ZonkAny 0)) -> f (i, a) -> g ()
    forall (t :: * -> *) (f :: * -> *) a b.
    (Foldable t, Applicative f) =>
    (a -> f b) -> t a -> f ()
    traverse_ (g b -> g (ZonkAny 0)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (g b -> g (ZonkAny 0))
    -> ((i, a) -> g b) -> (i, a) -> g (ZonkAny 0)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (i -> a -> g b) -> (i, a) -> g b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry (p a (g b) -> i -> a -> g b
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (g b)
    f)) (f (i, a) -> g ()) -> (s -> f (i, a)) -> s -> g ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . s -> f (i, a)
    sfa
    {-# INLINE ifolding #-}

    -- | Obtain a 'Fold' by lifting 'foldr' like function.
    --
    -- >>> [1,2,3,4]^..foldring foldr
    -- [1,2,3,4]
    foldring :: (Contravariant f, Applicative f) => ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
    foldring :: forall (f :: * -> *) a s t b.
    (Contravariant f, Applicative f) =>
    ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
    foldring (a -> f a -> f a) -> f a -> s -> f a
    fr a -> f b
    f = f a -> f t
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f t) -> (s -> f a) -> s -> f t
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> f a -> f a) -> f a -> s -> f a
    fr (\a
    a f a
    fa -> a -> f b
    f a
    a f b -> f a -> f a
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> f a
    fa) f a
    forall (f :: * -> *) a. (Contravariant f, Applicative f) => f a
    noEffect
    {-# INLINE foldring #-}

    -- | Obtain 'FoldWithIndex' by lifting 'ifoldr' like function.
    ifoldring :: (Indexable i p, Contravariant f, Applicative f) => ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
    ifoldring :: forall i (p :: * -> * -> *) (f :: * -> *) a s t b.
    (Indexable i p, Contravariant f, Applicative f) =>
    ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
    ifoldring (i -> a -> f a -> f a) -> f a -> s -> f a
    ifr p a (f b)
    f = f a -> f t
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f t) -> (s -> f a) -> s -> f t
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (i -> a -> f a -> f a) -> f a -> s -> f a
    ifr (\i
    i a
    a f a
    fa -> p a (f b) -> i -> a -> f b
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f b)
    f i
    i a
    a f b -> f a -> f a
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> f a
    fa) f a
    forall (f :: * -> *) a. (Contravariant f, Applicative f) => f a
    noEffect
    {-# INLINE ifoldring #-}

    -- | Obtain a 'Fold' from any 'Foldable' indexed by ordinal position.
    --
    -- >>> Just 3^..folded
    -- [3]
    --
    -- >>> Nothing^..folded
    -- []
    --
    -- >>> [(1,2),(3,4)]^..folded.both
    -- [1,2,3,4]
    folded :: Foldable f => IndexedFold Int (f a) a
    folded :: forall (f :: * -> *) a. Foldable f => IndexedFold Int (f a) a
    folded = ((p ~ (->)) => (a -> f a) -> f a -> f (f a))
    -> (p a (f a) -> f a -> f (f a)) -> p a (f a) -> f a -> f (f a)
    forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
    Conjoined p =>
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    forall (q :: * -> * -> *) a b r.
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    conjoined (((a -> f a -> f a) -> f a -> f a -> f a)
    -> (a -> f a) -> f a -> f (f a)
    forall (f :: * -> *) a s t b.
    (Contravariant f, Applicative f) =>
    ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
    foldring (a -> f a -> f a) -> f a -> f a -> f a
    forall a b. (a -> b -> b) -> b -> f a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr) (((Int -> a -> f a -> f a) -> f a -> f a -> f a)
    -> p a (f a) -> f a -> f (f a)
    forall i (p :: * -> * -> *) (f :: * -> *) a s t b.
    (Indexable i p, Contravariant f, Applicative f) =>
    ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
    ifoldring (Int -> a -> f a -> f a) -> f a -> f a -> f a
    forall (f :: * -> *) a b.
    Foldable f =>
    (Int -> a -> b -> b) -> b -> f a -> b
    ifoldr)
    {-# INLINE folded #-}

    ifoldr :: Foldable f => (Int -> a -> b -> b) -> b -> f a -> b
    ifoldr :: forall (f :: * -> *) a b.
    Foldable f =>
    (Int -> a -> b -> b) -> b -> f a -> b
    ifoldr Int -> a -> b -> b
    f b
    z f a
    xs = (a -> (Int -> b) -> Int -> b) -> (Int -> b) -> f a -> Int -> b
    forall a b. (a -> b -> b) -> b -> f a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\ a
    x Int -> b
    g Int
    i -> Int
    i Int -> b -> b
    forall a b. a -> b -> b
    `seq` Int -> a -> b -> b
    f Int
    i a
    x (Int -> b
    g (Int
    iInt -> Int -> Int
    forall a. Num a => a -> a -> a
    +Int
    1))) (b -> Int -> b
    forall a b. a -> b -> a
    const b
    z) f a
    xs Int
    0
    {-# INLINE ifoldr #-}

    -- | Obtain a 'Fold' from any 'Foldable' indexed by ordinal position.
    folded64 :: Foldable f => IndexedFold Int64 (f a) a
    folded64 :: forall (f :: * -> *) a. Foldable f => IndexedFold Int64 (f a) a
    folded64 = ((p ~ (->)) => (a -> f a) -> f a -> f (f a))
    -> (p a (f a) -> f a -> f (f a)) -> p a (f a) -> f a -> f (f a)
    forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
    Conjoined p =>
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    forall (q :: * -> * -> *) a b r.
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    conjoined (((a -> f a -> f a) -> f a -> f a -> f a)
    -> (a -> f a) -> f a -> f (f a)
    forall (f :: * -> *) a s t b.
    (Contravariant f, Applicative f) =>
    ((a -> f a -> f a) -> f a -> s -> f a) -> LensLike f s t a b
    foldring (a -> f a -> f a) -> f a -> f a -> f a
    forall a b. (a -> b -> b) -> b -> f a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr) (((Int64 -> a -> f a -> f a) -> f a -> f a -> f a)
    -> p a (f a) -> f a -> f (f a)
    forall i (p :: * -> * -> *) (f :: * -> *) a s t b.
    (Indexable i p, Contravariant f, Applicative f) =>
    ((i -> a -> f a -> f a) -> f a -> s -> f a) -> Over p f s t a b
    ifoldring (Int64 -> a -> f a -> f a) -> f a -> f a -> f a
    forall (f :: * -> *) a b.
    Foldable f =>
    (Int64 -> a -> b -> b) -> b -> f a -> b
    ifoldr64)
    {-# INLINE folded64 #-}

    ifoldr64 :: Foldable f => (Int64 -> a -> b -> b) -> b -> f a -> b
    ifoldr64 :: forall (f :: * -> *) a b.
    Foldable f =>
    (Int64 -> a -> b -> b) -> b -> f a -> b
    ifoldr64 Int64 -> a -> b -> b
    f b
    z f a
    xs = (a -> (Int64 -> b) -> Int64 -> b)
    -> (Int64 -> b) -> f a -> Int64 -> b
    forall a b. (a -> b -> b) -> b -> f a -> b
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr (\ a
    x Int64 -> b
    g Int64
    i -> Int64
    i Int64 -> b -> b
    forall a b. a -> b -> b
    `seq` Int64 -> a -> b -> b
    f Int64
    i a
    x (Int64 -> b
    g (Int64
    iInt64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    +Int64
    1))) (b -> Int64 -> b
    forall a b. a -> b -> a
    const b
    z) f a
    xs Int64
    0
    {-# INLINE ifoldr64 #-}

    -- | Form a 'Fold1' by repeating the input forever.
    --
    -- @
    -- 'repeat' ≡ 'toListOf' 'repeated'
    -- @
    --
    -- >>> timingOut $ 5^..taking 20 repeated
    -- [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]
    --
    -- @
    -- 'repeated' :: 'Fold1' a a
    -- @
    repeated :: Apply f => LensLike' f a a
    repeated :: forall (f :: * -> *) a. Apply f => LensLike' f a a
    repeated a -> f a
    f a
    a = f a
    forall {b}. f b
    as where as :: f b
    as = a -> f a
    f a
    a f a -> f b -> f b
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Apply f => f a -> f b -> f b
    .> f b
    as
    {-# INLINE repeated #-}

    -- | A 'Fold' that replicates its input @n@ times.
    --
    -- @
    -- 'replicate' n ≡ 'toListOf' ('replicated' n)
    -- @
    --
    -- >>> 5^..replicated 20
    -- [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]
    replicated :: Int -> Fold a a
    replicated :: forall a. Int -> Fold a a
    replicated Int
    n0 a -> f a
    f a
    a = Int -> f a
    forall {t} {a}. (Eq t, Num t) => t -> f a
    go Int
    n0 where
      m :: f a
    m = a -> f a
    f a
    a
      go :: t -> f a
    go t
    0 = f a
    forall (f :: * -> *) a. (Contravariant f, Applicative f) => f a
    noEffect
      go t
    n = f a
    m f a -> f a -> f a
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> t -> f a
    go (t
    n t -> t -> t
    forall a. Num a => a -> a -> a
    - t
    1)
    {-# INLINE replicated #-}

    -- | Transform a non-empty 'Fold' into a 'Fold1' that loops over its elements over and over.
    --
    -- >>> timingOut $ [1,2,3]^..taking 7 (cycled traverse)
    -- [1,2,3,1,2,3,1]
    --
    -- @
    -- 'cycled' :: 'Fold1' s a -> 'Fold1' s a
    -- @
    cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
    cycled :: forall (f :: * -> *) s t a b.
    Apply f =>
    LensLike f s t a b -> LensLike f s t a b
    cycled LensLike f s t a b
    l a -> f b
    f s
    a = f t
    forall {b}. f b
    as where as :: f b
    as = LensLike f s t a b
    l a -> f b
    f s
    a f t -> f b -> f b
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Apply f => f a -> f b -> f b
    .> f b
    as
    {-# INLINE cycled #-}

    -- | Build a 'Fold' that unfolds its values from a seed.
    --
    -- @
    -- 'Prelude.unfoldr' ≡ 'toListOf' '.' 'unfolded'
    -- @
    --
    -- >>> 10^..unfolded (\b -> if b == 0 then Nothing else Just (b, b-1))
    -- [10,9,8,7,6,5,4,3,2,1]
    unfolded :: (b -> Maybe (a, b)) -> Fold b a
    unfolded :: forall b a. (b -> Maybe (a, b)) -> Fold b a
    unfolded b -> Maybe (a, b)
    f a -> f a
    g = b -> f b
    forall {b}. b -> f b
    go where
      go :: b -> f b
    go b
    b = case b -> Maybe (a, b)
    f b
    b of
        Just (a
    a, b
    b') -> a -> f a
    g a
    a f a -> f b -> f b
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> b -> f b
    go b
    b'
        Maybe (a, b)
    Nothing      -> f b
    forall (f :: * -> *) a. (Contravariant f, Applicative f) => f a
    noEffect
    {-# INLINE unfolded #-}

    -- | @x '^.' 'iterated' f@ returns an infinite 'Fold1' of repeated applications of @f@ to @x@.
    --
    -- @
    -- 'toListOf' ('iterated' f) a ≡ 'iterate' f a
    -- @
    --
    -- @
    -- 'iterated' :: (a -> a) -> 'Fold1' a a
    -- @
    iterated :: Apply f => (a -> a) -> LensLike' f a a
    iterated :: forall (f :: * -> *) a. Apply f => (a -> a) -> LensLike' f a a
    iterated a -> a
    f a -> f a
    g = a -> f a
    forall {b}. a -> f b
    go where
      go :: a -> f b
    go a
    a = a -> f a
    g a
    a f a -> f b -> f b
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Apply f => f a -> f b -> f b
    .> a -> f b
    go (a -> a
    f a
    a)
    {-# INLINE iterated #-}

    -- | Obtain a 'Fold' that can be composed with to filter another 'Lens', 'Iso', 'Getter', 'Fold' (or 'Traversal').
    --
    -- Note: This is /not/ a legal 'Traversal', unless you are very careful not to invalidate the predicate on the target.
    --
    -- Note: This is also /not/ a legal 'Prism', unless you are very careful not to inject a value that fails the predicate.
    --
    -- As a counter example, consider that given @evens = 'filtered' 'even'@ the second 'Traversal' law is violated:
    --
    -- @
    -- 'Control.Lens.Setter.over' evens 'succ' '.' 'Control.Lens.Setter.over' evens 'succ' '/=' 'Control.Lens.Setter.over' evens ('succ' '.' 'succ')
    -- @
    --
    -- So, in order for this to qualify as a legal 'Traversal' you can only use it for actions that preserve the result of the predicate!
    --
    -- >>> [1..10]^..folded.filtered even
    -- [2,4,6,8,10]
    --
    -- This will preserve an index if it is present.
    filtered :: (Choice p, Applicative f) => (a -> Bool) -> Optic' p f a a
    filtered :: forall (p :: * -> * -> *) (f :: * -> *) a.
    (Choice p, Applicative f) =>
    (a -> Bool) -> Optic' p f a a
    filtered a -> Bool
    p = (a -> Either a a)
    -> (Either a (f a) -> f a)
    -> p (Either a a) (Either a (f a))
    -> p a (f a)
    forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap (\a
    x -> if a -> Bool
    p a
    x then a -> Either a a
    forall a b. b -> Either a b
    Right a
    x else a -> Either a a
    forall a b. a -> Either a b
    Left a
    x) ((a -> f a) -> (f a -> f a) -> Either a (f a) -> f a
    forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
    either a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure f a -> f a
    forall a. a -> a
    id) (p (Either a a) (Either a (f a)) -> p a (f a))
    -> (p a (f a) -> p (Either a a) (Either a (f a)))
    -> p a (f a)
    -> p a (f a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . p a (f a) -> p (Either a a) (Either a (f a))
    forall a b c. p a b -> p (Either c a) (Either c b)
    forall (p :: * -> * -> *) a b c.
    Choice p =>
    p a b -> p (Either c a) (Either c b)
    right'
    {-# INLINE filtered #-}

    -- | Obtain a potentially empty 'IndexedTraversal' by taking the first element from another,
    -- potentially empty `Fold` and using it as an index.
    --
    -- The resulting optic can be composed with to filter another 'Lens', 'Iso', 'Getter', 'Fold' (or 'Traversal').
    --
    -- >>> [(Just 2, 3), (Nothing, 4)] & mapped . filteredBy (_1 . _Just) <. _2 %@~ (*) :: [(Maybe Int, Int)]
    -- [(Just 2,6),(Nothing,4)]
    --
    -- @
    -- 'filteredBy' :: 'Fold' a i -> 'IndexedTraversal'' i a a
    -- @
    --
    -- Note: As with 'filtered', this is /not/ a legal 'IndexedTraversal', unless you are very careful not to invalidate the predicate on the target!
    filteredBy :: (Indexable i p, Applicative f) => Getting (First i) a i -> p a (f a) -> a -> f a
    filteredBy :: forall i (p :: * -> * -> *) (f :: * -> *) a.
    (Indexable i p, Applicative f) =>
    Getting (First i) a i -> p a (f a) -> a -> f a
    filteredBy Getting (First i) a i
    p p a (f a)
    f a
    val = case a
    val a -> Getting (First i) a i -> Maybe i
    forall s a. s -> Getting (First a) s a -> Maybe a
    ^? Getting (First i) a i
    p of
      Maybe i
    Nothing -> a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    val
      Just i
    witness -> p a (f a) -> i -> a -> f a
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f a)
    f i
    witness a
    val

    -- | Obtain a 'Fold' by taking elements from another 'Fold', 'Lens', 'Iso', 'Getter' or 'Traversal' while a predicate holds.
    --
    -- @
    -- 'takeWhile' p ≡ 'toListOf' ('takingWhile' p 'folded')
    -- @
    --
    -- >>> timingOut $ toListOf (takingWhile (<=3) folded) [1..]
    -- [1,2,3]
    --
    -- @
    -- 'takingWhile' :: (a -> 'Bool') -> 'Fold' s a                         -> 'Fold' s a
    -- 'takingWhile' :: (a -> 'Bool') -> 'Getter' s a                       -> 'Fold' s a
    -- 'takingWhile' :: (a -> 'Bool') -> 'Traversal'' s a                   -> 'Fold' s a -- * See note below
    -- 'takingWhile' :: (a -> 'Bool') -> 'Lens'' s a                        -> 'Fold' s a -- * See note below
    -- 'takingWhile' :: (a -> 'Bool') -> 'Prism'' s a                       -> 'Fold' s a -- * See note below
    -- 'takingWhile' :: (a -> 'Bool') -> 'Iso'' s a                         -> 'Fold' s a -- * See note below
    -- 'takingWhile' :: (a -> 'Bool') -> 'IndexedTraversal'' i s a          -> 'IndexedFold' i s a -- * See note below
    -- 'takingWhile' :: (a -> 'Bool') -> 'IndexedLens'' i s a               -> 'IndexedFold' i s a -- * See note below
    -- 'takingWhile' :: (a -> 'Bool') -> 'IndexedFold' i s a                -> 'IndexedFold' i s a
    -- 'takingWhile' :: (a -> 'Bool') -> 'IndexedGetter' i s a              -> 'IndexedFold' i s a
    -- @
    --
    -- /Note:/ When applied to a 'Traversal', 'takingWhile' yields something that can be used as if it were a 'Traversal', but
    -- which is not a 'Traversal' per the laws, unless you are careful to ensure that you do not invalidate the predicate when
    -- writing back through it.
    takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
    takingWhile :: forall (p :: * -> * -> *) (f :: * -> *) a s t.
    (Conjoined p, Applicative f) =>
    (a -> Bool)
    -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
    takingWhile a -> Bool
    p Over p (TakingWhile p f a a) s t a a
    l p a (f a)
    pafb = (Magma () t a a -> t) -> f (Magma () t a a) -> f t
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap Magma () t a a -> t
    forall i t a. Magma i t a a -> t
    runMagma (f (Magma () t a a) -> f t)
    -> (s -> f (Magma () t a a)) -> s -> f t
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Corep p a -> f a)
    -> Magma () t a (Corep p a) -> f (Magma () t a a)
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Magma () t a a -> f (Magma () t a b)
    traverse (p a (f a) -> Corep p a -> f a
    forall a b. p a b -> Corep p a -> b
    forall (p :: * -> * -> *) (f :: * -> *) a b.
    Cosieve p f =>
    p a b -> f a -> b
    cosieve p a (f a)
    pafb) (Magma () t a (Corep p a) -> f (Magma () t a a))
    -> (s -> Magma () t a (Corep p a)) -> s -> f (Magma () t a a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TakingWhile p f a a t -> Magma () t a (Corep p a)
    forall (p :: * -> * -> *) (f :: * -> *) a b t.
    TakingWhile p f a b t -> Magma () t b (Corep p a)
    runTakingWhile (TakingWhile p f a a t -> Magma () t a (Corep p a))
    -> (s -> TakingWhile p f a a t) -> s -> Magma () t a (Corep p a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Over p (TakingWhile p f a a) s t a a
    l p a (TakingWhile p f a a a)
    forall {g :: * -> *}. p a (TakingWhile p g a a a)
    flag where
      flag :: p a (TakingWhile p g a a a)
    flag = (Corep p a -> TakingWhile p g a a a) -> p a (TakingWhile p g a a a)
    forall d c. (Corep p d -> c) -> p d c
    forall (p :: * -> * -> *) d c.
    Corepresentable p =>
    (Corep p d -> c) -> p d c
    cotabulate ((Corep p a -> TakingWhile p g a a a)
     -> p a (TakingWhile p g a a a))
    -> (Corep p a -> TakingWhile p g a a a)
    -> p a (TakingWhile p g a a a)
    forall a b. (a -> b) -> a -> b
    $ \Corep p a
    wa -> let a :: a
    a = Corep p a -> a
    forall a. Corep p a -> a
    forall (w :: * -> *) a. Comonad w => w a -> a
    extract Corep p a
    wa; r :: Bool
    r = a -> Bool
    p a
    a in Bool
    -> a -> (Bool -> Magma () a a (Corep p a)) -> TakingWhile p g a a a
    forall (p :: * -> * -> *) (g :: * -> *) a b t.
    Bool
    -> t -> (Bool -> Magma () t b (Corep p a)) -> TakingWhile p g a b t
    TakingWhile Bool
    r a
    a ((Bool -> Magma () a a (Corep p a)) -> TakingWhile p g a a a)
    -> (Bool -> Magma () a a (Corep p a)) -> TakingWhile p g a a a
    forall a b. (a -> b) -> a -> b
    $ \Bool
    pr ->
        if Bool
    pr Bool -> Bool -> Bool
    && Bool
    r then () -> Corep p a -> Magma () a a (Corep p a)
    forall i a t. i -> a -> Magma i t t a
    Magma () Corep p a
    wa else a -> Magma () a a (Corep p a)
    forall t i b a. t -> Magma i t b a
    MagmaPure a
    a
    {-# INLINE takingWhile #-}

    -- | 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]
    --
    -- >>> toListOf (droppingWhile (<=3) folded) [1,6,1]
    -- [6,1]
    --
    -- @
    -- 'droppingWhile' :: (a -> 'Bool') -> 'Fold' s a                         -> 'Fold' s a
    -- 'droppingWhile' :: (a -> 'Bool') -> 'Getter' s a                       -> 'Fold' s a
    -- 'droppingWhile' :: (a -> 'Bool') -> 'Traversal'' s a                   -> 'Fold' s a                -- see notes
    -- 'droppingWhile' :: (a -> 'Bool') -> 'Lens'' s a                        -> 'Fold' s a                -- see notes
    -- 'droppingWhile' :: (a -> 'Bool') -> 'Prism'' s a                       -> 'Fold' s a                -- see notes
    -- 'droppingWhile' :: (a -> 'Bool') -> 'Iso'' s a                         -> 'Fold' s a                -- see notes
    -- @
    --
    -- @
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingTraversal'' s a    -> 'IndexPreservingFold' s a -- see notes
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingLens'' s a         -> 'IndexPreservingFold' s a -- see notes
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingGetter' s a        -> 'IndexPreservingFold' s a
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexPreservingFold' s a          -> 'IndexPreservingFold' s a
    -- @
    --
    -- @
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedTraversal'' i s a          -> 'IndexedFold' i s a       -- see notes
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedLens'' i s a               -> 'IndexedFold' i s a       -- see notes
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedGetter' i s a              -> 'IndexedFold' i s a
    -- 'droppingWhile' :: (a -> 'Bool') -> 'IndexedFold' i s a                -> 'IndexedFold' i s a
    -- @
    --
    -- Note: Many uses of this combinator will yield something that meets the types, but not the laws of a valid
    -- 'Traversal' or 'IndexedTraversal'. The 'Traversal' and 'IndexedTraversal' laws are only satisfied if the
    -- new values you assign to the first target also does not pass the predicate! Otherwise subsequent traversals
    -- will visit fewer elements and 'Traversal' fusion is not sound.
    --
    -- So for any traversal @t@ and predicate @p@, @`droppingWhile` p t@ may not be lawful, but
    -- @(`Control.Lens.Traversal.dropping` 1 . `droppingWhile` p) t@ is. For example:
    --
    -- >>> let l  :: Traversal' [Int] Int; l  = droppingWhile (<= 1) traverse
    -- >>> let l' :: Traversal' [Int] Int; l' = dropping 1 l
    --
    -- @l@ is not a lawful setter because @`Control.Lens.Setter.over` l f .
    -- `Control.Lens.Setter.over` l g ≢ `Control.Lens.Setter.over` l (f . g)@:
    --
    -- >>> [1,2,3] & l .~ 0 & l .~ 4
    -- [1,0,0]
    -- >>> [1,2,3] & l .~ 4
    -- [1,4,4]
    --
    -- @l'@ on the other hand behaves lawfully:
    --
    -- >>> [1,2,3] & l' .~ 0 & l' .~ 4
    -- [1,2,4]
    -- >>> [1,2,3] & l' .~ 4
    -- [1,2,4]
    droppingWhile :: (Conjoined p, Profunctor q, Applicative f)
                  => (a -> Bool)
                  -> Optical p q (Compose (State Bool) f) s t a a
                  -> Optical p q f s t a a
    droppingWhile :: forall (p :: * -> * -> *) (q :: * -> * -> *) (f :: * -> *) a s t.
    (Conjoined p, Profunctor q, Applicative f) =>
    (a -> Bool)
    -> Optical p q (Compose (State Bool) f) s t a a
    -> Optical p q f s t a a
    droppingWhile a -> Bool
    p Optical p q (Compose (State Bool) f) s t a a
    l p a (f a)
    f = ((State Bool (f t) -> Bool -> f t)
    -> Bool -> State Bool (f t) -> f t
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip State Bool (f t) -> Bool -> f t
    forall s a. State s a -> s -> a
    evalState Bool
    True (State Bool (f t) -> f t)
    -> (Compose (State Bool) f t -> State Bool (f t))
    -> Compose (State Bool) f t
    -> f t
    forall a b c (q :: * -> * -> *).
    Coercible b a =>
    (b -> c) -> q a b -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible b a) =>
    p b c -> q a b -> p a c
    .# Compose (State Bool) f t -> State Bool (f t)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    getCompose) (Compose (State Bool) f t -> f t)
    -> q s (Compose (State Bool) f t) -> q s (f t)
    forall b c a. (b -> c) -> q a b -> q a c
    forall (p :: * -> * -> *) b c a.
    Profunctor p =>
    (b -> c) -> p a b -> p a c
    `rmap` Optical p q (Compose (State Bool) f) s t a a
    l p a (Compose (State Bool) f a)
    g where
      g :: p a (Compose (State Bool) f a)
    g = (Corep p a -> Compose (State Bool) f a)
    -> p a (Compose (State Bool) f a)
    forall d c. (Corep p d -> c) -> p d c
    forall (p :: * -> * -> *) d c.
    Corepresentable p =>
    (Corep p d -> c) -> p d c
    cotabulate ((Corep p a -> Compose (State Bool) f a)
     -> p a (Compose (State Bool) f a))
    -> (Corep p a -> Compose (State Bool) f a)
    -> p a (Compose (State Bool) f a)
    forall a b. (a -> b) -> a -> b
    $ \Corep p a
    wa -> State Bool (f a) -> Compose (State Bool) f a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Compose (State Bool (f a) -> Compose (State Bool) f a)
    -> State Bool (f a) -> Compose (State Bool) f a
    forall a b. (a -> b) -> a -> b
    $ (Bool -> (f a, Bool)) -> State Bool (f a)
    forall a. (Bool -> (a, Bool)) -> State Bool a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    state ((Bool -> (f a, Bool)) -> State Bool (f a))
    -> (Bool -> (f a, Bool)) -> State Bool (f a)
    forall a b. (a -> b) -> a -> b
    $ \Bool
    b -> let
          a :: a
    a = Corep p a -> a
    forall a. Corep p a -> a
    forall (w :: * -> *) a. Comonad w => w a -> a
    extract Corep p a
    wa
          b' :: Bool
    b' = Bool
    b Bool -> Bool -> Bool
    && a -> Bool
    p a
    a
        in (if Bool
    b' then a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    a else p a (f a) -> Corep p a -> f a
    forall a b. p a b -> Corep p a -> b
    forall (p :: * -> * -> *) (f :: * -> *) a b.
    Cosieve p f =>
    p a b -> f a -> b
    cosieve p a (f a)
    f Corep p a
    wa, Bool
    b')
    {-# INLINE droppingWhile #-}

    -- | A 'Fold' over the individual 'words' of a 'String'.
    --
    -- @
    -- 'worded' :: 'Fold' 'String' 'String'
    -- 'worded' :: 'Traversal'' 'String' 'String'
    -- @
    --
    -- @
    -- 'worded' :: 'IndexedFold' 'Int' 'String' 'String'
    -- 'worded' :: 'IndexedTraversal'' 'Int' 'String' 'String'
    -- @
    --
    -- Note: This function type-checks as a 'Traversal' but it doesn't satisfy the laws. It's only valid to use it
    -- when you don't insert any whitespace characters while traversing, and if your original 'String' contains only
    -- isolated space characters (and no other characters that count as space, such as non-breaking spaces).
    worded :: Applicative f => IndexedLensLike' Int f String String
    worded :: forall (f :: * -> *).
    Applicative f =>
    IndexedLensLike' Int f String String
    worded p String (f String)
    f = ([String] -> String) -> f [String] -> f String
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [String] -> String
    unwords (f [String] -> f String)
    -> (String -> f [String]) -> String -> f String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((p ~ (->)) => (String -> f String) -> [String] -> f [String])
    -> (p String (f String) -> [String] -> f [String])
    -> p String (f String)
    -> [String]
    -> f [String]
    forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
    Conjoined p =>
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    forall (q :: * -> * -> *) a b r.
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    conjoined (p ~ (->)) => (String -> f String) -> [String] -> f [String]
    (String -> f String) -> [String] -> f [String]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (((String -> Indexing f String) -> [String] -> Indexing f [String])
    -> p String (f String) -> [String] -> f [String]
    forall (p :: * -> * -> *) a (f :: * -> *) b s t.
    Indexable Int p =>
    ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
    indexing (String -> Indexing f String) -> [String] -> Indexing f [String]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse) p String (f String)
    f ([String] -> f [String])
    -> (String -> [String]) -> String -> f [String]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> [String]
    words
    {-# INLINE worded #-}

    -- | A 'Fold' over the individual 'lines' of a 'String'.
    --
    -- @
    -- 'lined' :: 'Fold' 'String' 'String'
    -- 'lined' :: 'Traversal'' 'String' 'String'
    -- @
    --
    -- @
    -- 'lined' :: 'IndexedFold' 'Int' 'String' 'String'
    -- 'lined' :: 'IndexedTraversal'' 'Int' 'String' 'String'
    -- @
    --
    -- Note: This function type-checks as a 'Traversal' but it doesn't satisfy the laws. It's only valid to use it
    -- when you don't insert any newline characters while traversing, and if your original 'String' contains only
    -- isolated newline characters.
    lined :: Applicative f => IndexedLensLike' Int f String String
    lined :: forall (f :: * -> *).
    Applicative f =>
    IndexedLensLike' Int f String String
    lined p String (f String)
    f = ([String] -> String) -> f [String] -> f String
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (String -> [String] -> String
    forall a. [a] -> [[a]] -> [a]
    intercalate String
    "\n") (f [String] -> f String)
    -> (String -> f [String]) -> String -> f String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((p ~ (->)) => (String -> f String) -> [String] -> f [String])
    -> (p String (f String) -> [String] -> f [String])
    -> p String (f String)
    -> [String]
    -> f [String]
    forall (p :: * -> * -> *) (q :: * -> * -> *) a b r.
    Conjoined p =>
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    forall (q :: * -> * -> *) a b r.
    ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
    conjoined (p ~ (->)) => (String -> f String) -> [String] -> f [String]
    (String -> f String) -> [String] -> f [String]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse (((String -> Indexing f String) -> [String] -> Indexing f [String])
    -> p String (f String) -> [String] -> f [String]
    forall (p :: * -> * -> *) a (f :: * -> *) b s t.
    Indexable Int p =>
    ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
    indexing (String -> Indexing f String) -> [String] -> Indexing f [String]
    forall (t :: * -> *) (f :: * -> *) a b.
    (Traversable t, Applicative f) =>
    (a -> f b) -> t a -> f (t b)
    forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> [a] -> f [b]
    traverse) p String (f String)
    f ([String] -> f [String])
    -> (String -> [String]) -> String -> f [String]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . String -> [String]
    lines
    {-# INLINE lined #-}

    --------------------------
    -- Fold/Getter combinators
    --------------------------

    -- | Map each part of a structure viewed through a 'Lens', 'Getter',
    -- 'Fold' or 'Traversal' to a monoid and combine the results.
    --
    -- >>> foldMapOf (folded . both . _Just) Sum [(Just 21, Just 21)]
    -- Sum {getSum = 42}
    --
    -- @
    -- 'Data.Foldable.foldMap' = 'foldMapOf' 'folded'
    -- @
    --
    -- @
    -- 'foldMapOf' ≡ 'views'
    -- 'ifoldMapOf' l = 'foldMapOf' l '.' 'Indexed'
    -- @
    --
    -- @
    -- 'foldMapOf' ::                'Getter' s a      -> (a -> r) -> s -> r
    -- 'foldMapOf' :: 'Monoid' r    => 'Fold' s a        -> (a -> r) -> s -> r
    -- 'foldMapOf' :: 'Semigroup' r => 'Fold1' s a       -> (a -> r) -> s -> r
    -- 'foldMapOf' ::                'Lens'' s a       -> (a -> r) -> s -> r
    -- 'foldMapOf' ::                'Iso'' s a        -> (a -> r) -> s -> r
    -- 'foldMapOf' :: 'Monoid' r    => 'Traversal'' s a  -> (a -> r) -> s -> r
    -- 'foldMapOf' :: 'Semigroup' r => 'Traversal1'' s a -> (a -> r) -> s -> r
    -- 'foldMapOf' :: 'Monoid' r    => 'Prism'' s a      -> (a -> r) -> s -> r
    -- @
    --
    -- @
    -- 'foldMapOf' :: 'Getting' r s a -> (a -> r) -> s -> r
    -- @
    foldMapOf :: Getting r s a -> (a -> r) -> s -> r
    foldMapOf :: forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf = Getting r s a -> (a -> r) -> s -> r
    forall a b. Coercible a b => a -> b
    coerce
    {-# INLINE foldMapOf #-}

    -- | Combine the elements of a structure viewed through a 'Lens', 'Getter',
    -- 'Fold' or 'Traversal' using a monoid.
    --
    -- >>> foldOf (folded.folded) [[Sum 1,Sum 4],[Sum 8, Sum 8],[Sum 21]]
    -- Sum {getSum = 42}
    --
    -- @
    -- 'Data.Foldable.fold' = 'foldOf' 'folded'
    -- @
    --
    -- @
    -- 'foldOf' ≡ 'view'
    -- @
    --
    -- @
    -- 'foldOf' ::             'Getter' s m     -> s -> m
    -- 'foldOf' :: 'Monoid' m => 'Fold' s m       -> s -> m
    -- 'foldOf' ::             'Lens'' s m      -> s -> m
    -- 'foldOf' ::             'Iso'' s m       -> s -> m
    -- 'foldOf' :: 'Monoid' m => 'Traversal'' s m -> s -> m
    -- 'foldOf' :: 'Monoid' m => 'Prism'' s m     -> s -> m
    -- @
    foldOf :: Getting a s a -> s -> a
    foldOf :: forall a s. Getting a s a -> s -> a
    foldOf Getting a s a
    l = Const a s -> a
    forall {k} a (b :: k). Const a b -> a
    getConst (Const a s -> a) -> (s -> Const a s) -> s -> a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting a s a
    l a -> Const a a
    forall {k} a (b :: k). a -> Const a b
    Const
    {-# INLINE foldOf #-}

    -- | Right-associative fold of parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Traversal'.
    --
    -- @
    -- 'Data.Foldable.foldr' ≡ 'foldrOf' 'folded'
    -- @
    --
    -- @
    -- 'foldrOf' :: 'Getter' s a     -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf' :: 'Fold' s a       -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf' :: 'Lens'' s a      -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf' :: 'Iso'' s a       -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf' :: 'Traversal'' s a -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf' :: 'Prism'' s a     -> (a -> r -> r) -> r -> s -> r
    -- @
    --
    -- @
    -- 'ifoldrOf' l ≡ 'foldrOf' l '.' 'Indexed'
    -- @
    --
    -- @
    -- 'foldrOf' :: 'Getting' ('Endo' r) s a -> (a -> r -> r) -> r -> s -> r
    -- @
    foldrOf :: Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf :: forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo r) s a
    l a -> r -> r
    f r
    z = (Endo r -> r -> r) -> r -> Endo r -> r
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Endo r -> r -> r
    forall a. Endo a -> a -> a
    appEndo r
    z (Endo r -> r) -> (s -> Endo r) -> s -> r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Endo r) s a -> (a -> Endo r) -> s -> Endo r
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Endo r) s a
    l ((r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo ((r -> r) -> Endo r) -> (a -> r -> r) -> a -> Endo r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> r -> r
    f)
    {-# INLINE foldrOf #-}

    -- | Left-associative fold of the parts of a structure that are viewed through a 'Lens', 'Getter', 'Fold' or 'Traversal'.
    --
    -- @
    -- 'Data.Foldable.foldl' ≡ 'foldlOf' 'folded'
    -- @
    --
    -- @
    -- 'foldlOf' :: 'Getter' s a     -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf' :: 'Fold' s a       -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf' :: 'Lens'' s a      -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf' :: 'Iso'' s a       -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf' :: 'Traversal'' s a -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf' :: 'Prism'' s a     -> (r -> a -> r) -> r -> s -> r
    -- @
    foldlOf :: Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf :: forall r s a.
    Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf Getting (Dual (Endo r)) s a
    l r -> a -> r
    f r
    z = ((Endo r -> r -> r) -> r -> Endo r -> r
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Endo r -> r -> r
    forall a. Endo a -> a -> a
    appEndo r
    z (Endo r -> r) -> (Dual (Endo r) -> Endo r) -> Dual (Endo r) -> r
    forall a b c (q :: * -> * -> *).
    Coercible b a =>
    (b -> c) -> q a b -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible b a) =>
    p b c -> q a b -> p a c
    .# Dual (Endo r) -> Endo r
    forall a. Dual a -> a
    getDual) (Dual (Endo r) -> r) -> (s -> Dual (Endo r)) -> s -> r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) b c a.
    Profunctor p =>
    (b -> c) -> p a b -> p a c
    `rmap` Getting (Dual (Endo r)) s a
    -> (a -> Dual (Endo r)) -> s -> Dual (Endo r)
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Dual (Endo r)) s a
    l (Endo r -> Dual (Endo r)
    forall a. a -> Dual a
    Dual (Endo r -> Dual (Endo r)) -> (a -> Endo r) -> a -> Dual (Endo r)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo ((r -> r) -> Endo r) -> (a -> r -> r) -> a -> Endo r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (r -> a -> r) -> a -> r -> r
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip r -> a -> r
    f)
    {-# INLINE foldlOf #-}

    -- | Extract a list of the targets of a 'Fold'. See also ('^..').
    --
    -- @
    -- 'Data.Foldable.toList' ≡ 'toListOf' 'folded'
    -- ('^..') ≡ 'flip' 'toListOf'
    -- @

    -- >>> toListOf both ("hello","world")
    -- ["hello","world"]
    --
    -- @
    -- 'toListOf' :: 'Getter' s a     -> s -> [a]
    -- 'toListOf' :: 'Fold' s a       -> s -> [a]
    -- 'toListOf' :: 'Lens'' s a      -> s -> [a]
    -- 'toListOf' :: 'Iso'' s a       -> s -> [a]
    -- 'toListOf' :: 'Traversal'' s a -> s -> [a]
    -- 'toListOf' :: 'Prism'' s a     -> s -> [a]
    -- @
    toListOf :: Getting (Endo [a]) s a -> s -> [a]
    toListOf :: forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    l = Getting (Endo [a]) s a -> (a -> [a] -> [a]) -> [a] -> s -> [a]
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo [a]) s a
    l (:) []
    {-# INLINE toListOf #-}

    -- | Extract a 'NonEmpty' of the targets of 'Fold1'.
    --
    -- >>> toNonEmptyOf both1 ("hello", "world")
    -- "hello" :| ["world"]
    --
    -- @
    -- 'toNonEmptyOf' :: 'Getter' s a      -> s -> NonEmpty a
    -- 'toNonEmptyOf' :: 'Fold1' s a       -> s -> NonEmpty a
    -- 'toNonEmptyOf' :: 'Lens'' s a       -> s -> NonEmpty a
    -- 'toNonEmptyOf' :: 'Iso'' s a        -> s -> NonEmpty a
    -- 'toNonEmptyOf' :: 'Traversal1'' s a -> s -> NonEmpty a
    -- @
    toNonEmptyOf :: Getting (NonEmptyDList a) s a -> s -> NonEmpty a
    toNonEmptyOf :: forall a s. Getting (NonEmptyDList a) s a -> s -> NonEmpty a
    toNonEmptyOf Getting (NonEmptyDList a) s a
    l = (NonEmptyDList a -> [a] -> NonEmpty a)
    -> [a] -> NonEmptyDList a -> NonEmpty a
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip NonEmptyDList a -> [a] -> NonEmpty a
    forall a. NonEmptyDList a -> [a] -> NonEmpty a
    getNonEmptyDList [] (NonEmptyDList a -> NonEmpty a)
    -> (s -> NonEmptyDList a) -> s -> NonEmpty a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (NonEmptyDList a) s a
    -> (a -> NonEmptyDList a) -> s -> NonEmptyDList a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (NonEmptyDList a) s a
    l (([a] -> NonEmpty a) -> NonEmptyDList a
    forall a. ([a] -> NonEmpty a) -> NonEmptyDList a
    NonEmptyDList (([a] -> NonEmpty a) -> NonEmptyDList a)
    -> (a -> [a] -> NonEmpty a) -> a -> NonEmptyDList a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> [a] -> NonEmpty a
    forall a. a -> [a] -> NonEmpty a
    (:|))

    -- | Calls 'pure' on the target of a 'Lens', 'Getter', or 'Iso'.
    --
    -- Calls 'pure' on the targets of a 'Traversal', 'Fold', or 'Prism', and
    -- combines them with '<|>' (or `empty` if none).  Intuitively, it collects
    -- targets into an 'Alternative' until the container fills up or it runs out of
    -- targets, whichever comes first.
    --
    -- Generalizes 'toListOf' and '(^?)'.
    --
    -- >>> altOf both ("hello", "world") :: [String]
    -- ["hello","world"]
    -- >>> altOf both ("hello", "world") :: Maybe String
    -- Just "hello"
    --
    -- @
    -- 'altOf' :: Applicative f => 'Lens'' s a      -> s -> f a
    -- 'altOf' :: Applicative f => 'Getter' s a     -> s -> f a
    -- 'altOf' :: Applicative f => 'Iso'' s a       -> s -> f a
    --
    -- 'altOf' :: Alternative f => 'Traversal'' s a -> s -> f a
    -- 'altOf' :: Alternative f => 'Fold' s a       -> s -> f a
    -- 'altOf' :: Alternative f => 'Prism'' s a     -> s -> f a
    -- @
    altOf :: Applicative f => Getting (Alt f a) s a -> s -> f a
    altOf :: forall (f :: * -> *) a s.
    Applicative f =>
    Getting (Alt f a) s a -> s -> f a
    altOf Getting (Alt f a) s a
    l = Alt f a -> f a
    forall {k} (f :: k -> *) (a :: k). Alt f a -> f a
    getAlt (Alt f a -> f a) -> (s -> Alt f a) -> s -> f a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (Alt f a) s a -> (a -> Alt f a) -> s -> Alt f a
    forall s (m :: * -> *) r a.
    MonadReader s m =>
    LensLike' (Const r) s a -> (a -> r) -> m r
    views Getting (Alt f a) s a
    l (f a -> Alt f a
    forall {k} (f :: k -> *) (a :: k). f a -> Alt f a
    Alt (f a -> Alt f a) -> (a -> f a) -> a -> Alt f a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure)
    {-# INLINE altOf #-}

    -- | A convenient infix (flipped) version of 'toListOf'.
    --
    -- >>> [[1,2],[3]]^..id
    -- [[[1,2],[3]]]
    -- >>> [[1,2],[3]]^..traverse
    -- [[1,2],[3]]
    -- >>> [[1,2],[3]]^..traverse.traverse
    -- [1,2,3]
    --
    -- >>> (1,2)^..both
    -- [1,2]
    --
    -- @
    -- 'Data.Foldable.toList' xs ≡ xs '^..' 'folded'
    -- ('^..') ≡ 'flip' 'toListOf'
    -- @
    --
    -- @
    -- ('^..') :: s -> 'Getter' s a     -> [a]
    -- ('^..') :: s -> 'Fold' s a       -> [a]
    -- ('^..') :: s -> 'Lens'' s a      -> [a]
    -- ('^..') :: s -> 'Iso'' s a       -> [a]
    -- ('^..') :: s -> 'Traversal'' s a -> [a]
    -- ('^..') :: s -> 'Prism'' s a     -> [a]
    -- @
    (^..) :: s -> Getting (Endo [a]) s a -> [a]
    s
    s ^.. :: forall s a. s -> Getting (Endo [a]) s a -> [a]
    ^.. Getting (Endo [a]) s a
    l = Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    l s
    s
    {-# INLINE (^..) #-}

    -- | Returns 'True' if every target of a 'Fold' is 'True'.
    --
    -- >>> andOf both (True,False)
    -- False
    -- >>> andOf both (True,True)
    -- True
    --
    -- @
    -- 'Data.Foldable.and' ≡ 'andOf' 'folded'
    -- @
    --
    -- @
    -- 'andOf' :: 'Getter' s 'Bool'     -> s -> 'Bool'
    -- 'andOf' :: 'Fold' s 'Bool'       -> s -> 'Bool'
    -- 'andOf' :: 'Lens'' s 'Bool'      -> s -> 'Bool'
    -- 'andOf' :: 'Iso'' s 'Bool'       -> s -> 'Bool'
    -- 'andOf' :: 'Traversal'' s 'Bool' -> s -> 'Bool'
    -- 'andOf' :: 'Prism'' s 'Bool'     -> s -> 'Bool'
    -- @
    andOf :: Getting All s Bool -> s -> Bool
    andOf :: forall s. Getting All s Bool -> s -> Bool
    andOf Getting All s Bool
    l = All -> Bool
    getAll (All -> Bool) -> (s -> All) -> s -> Bool
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting All s Bool -> (Bool -> All) -> s -> All
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting All s Bool
    l Bool -> All
    All
    {-# INLINE andOf #-}

    -- | Returns 'True' if any target of a 'Fold' is 'True'.
    --
    -- >>> orOf both (True,False)
    -- True
    -- >>> orOf both (False,False)
    -- False
    --
    -- @
    -- 'Data.Foldable.or' ≡ 'orOf' 'folded'
    -- @
    --
    -- @
    -- 'orOf' :: 'Getter' s 'Bool'     -> s -> 'Bool'
    -- 'orOf' :: 'Fold' s 'Bool'       -> s -> 'Bool'
    -- 'orOf' :: 'Lens'' s 'Bool'      -> s -> 'Bool'
    -- 'orOf' :: 'Iso'' s 'Bool'       -> s -> 'Bool'
    -- 'orOf' :: 'Traversal'' s 'Bool' -> s -> 'Bool'
    -- 'orOf' :: 'Prism'' s 'Bool'     -> s -> 'Bool'
    -- @
    orOf :: Getting Any s Bool -> s -> Bool
    orOf :: forall s. Getting Any s Bool -> s -> Bool
    orOf Getting Any s Bool
    l = Any -> Bool
    getAny (Any -> Bool) -> (s -> Any) -> s -> Bool
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting Any s Bool -> (Bool -> Any) -> s -> Any
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting Any s Bool
    l Bool -> Any
    Any
    {-# INLINE orOf #-}

    -- | Returns 'True' if any target of a 'Fold' satisfies a predicate.
    --
    -- >>> anyOf both (=='x') ('x','y')
    -- True
    -- >>> import Data.Data.Lens
    -- >>> anyOf biplate (== "world") (((),2::Int),"hello",("world",11::Int))
    -- True
    --
    -- @
    -- 'Data.Foldable.any' ≡ 'anyOf' 'folded'
    -- @
    --
    -- @
    -- 'ianyOf' l ≡ 'anyOf' l '.' 'Indexed'
    -- @
    --
    -- @
    -- 'anyOf' :: 'Getter' s a     -> (a -> 'Bool') -> s -> 'Bool'
    -- 'anyOf' :: 'Fold' s a       -> (a -> 'Bool') -> s -> 'Bool'
    -- 'anyOf' :: 'Lens'' s a      -> (a -> 'Bool') -> s -> 'Bool'
    -- 'anyOf' :: 'Iso'' s a       -> (a -> 'Bool') -> s -> 'Bool'
    -- 'anyOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Bool'
    -- 'anyOf' :: 'Prism'' s a     -> (a -> 'Bool') -> s -> 'Bool'
    -- @
    anyOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
    anyOf :: forall s a. Getting Any s a -> (a -> Bool) -> s -> Bool
    anyOf Getting Any s a
    l a -> Bool
    f = Any -> Bool
    getAny (Any -> Bool) -> (s -> Any) -> s -> Bool
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting Any s a -> (a -> Any) -> s -> Any
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting Any s a
    l (Bool -> Any
    Any (Bool -> Any) -> (a -> Bool) -> a -> Any
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> Bool
    f)
    {-# INLINE anyOf #-}

    -- | Returns 'True' if every target of a 'Fold' satisfies a predicate.
    --
    -- >>> allOf both (>=3) (4,5)
    -- True
    -- >>> allOf folded (>=2) [1..10]
    -- False
    --
    -- @
    -- 'Data.Foldable.all' ≡ 'allOf' 'folded'
    -- @
    --
    -- @
    -- 'iallOf' l = 'allOf' l '.' 'Indexed'
    -- @
    --
    -- @
    -- 'allOf' :: 'Getter' s a     -> (a -> 'Bool') -> s -> 'Bool'
    -- 'allOf' :: 'Fold' s a       -> (a -> 'Bool') -> s -> 'Bool'
    -- 'allOf' :: 'Lens'' s a      -> (a -> 'Bool') -> s -> 'Bool'
    -- 'allOf' :: 'Iso'' s a       -> (a -> 'Bool') -> s -> 'Bool'
    -- 'allOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Bool'
    -- 'allOf' :: 'Prism'' s a     -> (a -> 'Bool') -> s -> 'Bool'
    -- @
    allOf :: Getting All s a -> (a -> Bool) -> s -> Bool
    allOf :: forall s a. Getting All s a -> (a -> Bool) -> s -> Bool
    allOf Getting All s a
    l a -> Bool
    f = All -> Bool
    getAll (All -> Bool) -> (s -> All) -> s -> Bool
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting All s a -> (a -> All) -> s -> All
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting All s a
    l (Bool -> All
    All (Bool -> All) -> (a -> Bool) -> a -> All
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> Bool
    f)
    {-# INLINE allOf #-}

    -- | Returns 'True' only if no targets of a 'Fold' satisfy a predicate.
    --
    -- >>> noneOf each (is _Nothing) (Just 3, Just 4, Just 5)
    -- True
    -- >>> noneOf (folded.folded) (<10) [[13,99,20],[3,71,42]]
    -- False
    --
    -- @
    -- 'inoneOf' l = 'noneOf' l '.' 'Indexed'
    -- @
    --
    -- @
    -- 'noneOf' :: 'Getter' s a     -> (a -> 'Bool') -> s -> 'Bool'
    -- 'noneOf' :: 'Fold' s a       -> (a -> 'Bool') -> s -> 'Bool'
    -- 'noneOf' :: 'Lens'' s a      -> (a -> 'Bool') -> s -> 'Bool'
    -- 'noneOf' :: 'Iso'' s a       -> (a -> 'Bool') -> s -> 'Bool'
    -- 'noneOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Bool'
    -- 'noneOf' :: 'Prism'' s a     -> (a -> 'Bool') -> s -> 'Bool'
    -- @
    noneOf :: Getting Any s a -> (a -> Bool) -> s -> Bool
    noneOf :: forall s a. Getting Any s a -> (a -> Bool) -> s -> Bool
    noneOf Getting Any s a
    l a -> Bool
    f = Bool -> Bool
    not (Bool -> Bool) -> (s -> Bool) -> s -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting Any s a -> (a -> Bool) -> s -> Bool
    forall s a. Getting Any s a -> (a -> Bool) -> s -> Bool
    anyOf Getting Any s a
    l a -> Bool
    f
    {-# INLINE noneOf #-}

    -- | Calculate the 'Product' of every number targeted by a 'Fold'.
    --
    -- >>> productOf both (4,5)
    -- 20
    -- >>> productOf folded [1,2,3,4,5]
    -- 120
    --
    -- @
    -- 'Data.Foldable.product' ≡ 'productOf' 'folded'
    -- @
    --
    -- This operation may be more strict than you would expect. If you
    -- want a lazier version use @'ala' 'Product' '.' 'foldMapOf'@
    --
    -- @
    -- 'productOf' :: 'Num' a => 'Getter' s a     -> s -> a
    -- 'productOf' :: 'Num' a => 'Fold' s a       -> s -> a
    -- 'productOf' :: 'Num' a => 'Lens'' s a      -> s -> a
    -- 'productOf' :: 'Num' a => 'Iso'' s a       -> s -> a
    -- 'productOf' :: 'Num' a => 'Traversal'' s a -> s -> a
    -- 'productOf' :: 'Num' a => 'Prism'' s a     -> s -> a
    -- @
    productOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
    productOf :: forall a s. Num a => Getting (Endo (Endo a)) s a -> s -> a
    productOf Getting (Endo (Endo a)) s a
    l = Getting (Endo (Endo a)) s a -> (a -> a -> a) -> a -> s -> a
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo a)) s a
    l a -> a -> a
    forall a. Num a => a -> a -> a
    (*) a
    1
    {-# INLINE productOf #-}

    -- | Calculate the 'Sum' of every number targeted by a 'Fold'.
    --
    -- >>> 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
    --
    -- @
    -- 'Data.Foldable.sum' ≡ 'sumOf' 'folded'
    -- @
    --
    -- This operation may be more strict than you would expect. If you
    -- want a lazier version use @'ala' 'Sum' '.' 'foldMapOf'@
    --
    -- @
    -- 'sumOf' '_1' :: 'Num' a => (a, b) -> a
    -- 'sumOf' ('folded' '.' 'Control.Lens.Tuple._1') :: ('Foldable' f, 'Num' a) => f (a, b) -> a
    -- @
    --
    -- @
    -- 'sumOf' :: 'Num' a => 'Getter' s a     -> s -> a
    -- 'sumOf' :: 'Num' a => 'Fold' s a       -> s -> a
    -- 'sumOf' :: 'Num' a => 'Lens'' s a      -> s -> a
    -- 'sumOf' :: 'Num' a => 'Iso'' s a       -> s -> a
    -- 'sumOf' :: 'Num' a => 'Traversal'' s a -> s -> a
    -- 'sumOf' :: 'Num' a => 'Prism'' s a     -> s -> a
    -- @
    sumOf :: Num a => Getting (Endo (Endo a)) s a -> s -> a
    sumOf :: forall a s. Num a => Getting (Endo (Endo a)) s a -> s -> a
    sumOf Getting (Endo (Endo a)) s a
    l = Getting (Endo (Endo a)) s a -> (a -> a -> a) -> a -> s -> a
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo a)) s a
    l a -> a -> a
    forall a. Num a => a -> a -> a
    (+) a
    0
    {-# INLINE sumOf #-}

    -- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor')-based answer,
    -- but unlike 'Control.Lens.Traversal.traverseOf' do not construct a new structure. 'traverseOf_' generalizes
    -- 'Data.Foldable.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'.
    --
    -- >>> traverseOf_ both putStrLn ("hello","world")
    -- hello
    -- world
    --
    -- @
    -- 'Data.Foldable.traverse_' ≡ 'traverseOf_' 'folded'
    -- @
    --
    -- @
    -- 'traverseOf_' '_2' :: 'Functor' f => (c -> f r) -> (d, c) -> f ()
    -- 'traverseOf_' 'Control.Lens.Prism._Left' :: 'Applicative' f => (a -> f b) -> 'Either' a c -> f ()
    -- @
    --
    -- @
    -- 'itraverseOf_' l ≡ 'traverseOf_' l '.' 'Indexed'
    -- @
    --
    -- The rather specific signature of 'traverseOf_' allows it to be used as if the signature was any of:
    --
    -- @
    -- 'traverseOf_' :: 'Functor' f     => 'Getter' s a     -> (a -> f r) -> s -> f ()
    -- 'traverseOf_' :: 'Applicative' f => 'Fold' s a       -> (a -> f r) -> s -> f ()
    -- 'traverseOf_' :: 'Functor' f     => 'Lens'' s a      -> (a -> f r) -> s -> f ()
    -- 'traverseOf_' :: 'Functor' f     => 'Iso'' s a       -> (a -> f r) -> s -> f ()
    -- 'traverseOf_' :: 'Applicative' f => 'Traversal'' s a -> (a -> f r) -> s -> f ()
    -- 'traverseOf_' :: 'Applicative' f => 'Prism'' s a     -> (a -> f r) -> s -> f ()
    -- @
    traverseOf_ :: Functor f => Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
    traverseOf_ :: forall (f :: * -> *) r s a.
    Functor f =>
    Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
    traverseOf_ Getting (Traversed r f) s a
    l a -> f r
    f = f r -> f ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (f r -> f ()) -> (s -> f r) -> s -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Traversed r f -> f r
    forall a (f :: * -> *). Traversed a f -> f a
    getTraversed (Traversed r f -> f r) -> (s -> Traversed r f) -> s -> f r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (Traversed r f) s a
    -> (a -> Traversed r f) -> s -> Traversed r f
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Traversed r f) s a
    l (f r -> Traversed r f
    forall a (f :: * -> *). f a -> Traversed a f
    Traversed (f r -> Traversed r f) -> (a -> f r) -> a -> Traversed r f
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> f r
    f)
    {-# INLINE traverseOf_ #-}

    -- | Traverse over all of the targets of a 'Fold' (or 'Getter'), computing an 'Applicative' (or 'Functor')-based answer,
    -- but unlike 'Control.Lens.Traversal.forOf' do not construct a new structure. 'forOf_' generalizes
    -- 'Data.Foldable.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'
    -- @
    --
    -- >>> forOf_ both ("hello","world") putStrLn
    -- hello
    -- world
    --
    -- The rather specific signature of 'forOf_' allows it to be used as if the signature was any of:
    --
    -- @
    -- 'iforOf_' l s ≡ 'forOf_' l s '.' 'Indexed'
    -- @
    --
    -- @
    -- 'forOf_' :: 'Functor' f     => 'Getter' s a     -> s -> (a -> f r) -> f ()
    -- 'forOf_' :: 'Applicative' f => 'Fold' s a       -> s -> (a -> f r) -> f ()
    -- 'forOf_' :: 'Functor' f     => 'Lens'' s a      -> s -> (a -> f r) -> f ()
    -- 'forOf_' :: 'Functor' f     => 'Iso'' s a       -> s -> (a -> f r) -> f ()
    -- 'forOf_' :: 'Applicative' f => 'Traversal'' s a -> s -> (a -> f r) -> f ()
    -- 'forOf_' :: 'Applicative' f => 'Prism'' s a     -> s -> (a -> f r) -> f ()
    -- @
    forOf_ :: Functor f => Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()
    forOf_ :: forall (f :: * -> *) r s a.
    Functor f =>
    Getting (Traversed r f) s a -> s -> (a -> f r) -> f ()
    forOf_ = ((a -> f r) -> s -> f ()) -> s -> (a -> f r) -> f ()
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (((a -> f r) -> s -> f ()) -> s -> (a -> f r) -> f ())
    -> (Getting (Traversed r f) s a -> (a -> f r) -> s -> f ())
    -> Getting (Traversed r f) s a
    -> s
    -> (a -> f r)
    -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
    forall (f :: * -> *) r s a.
    Functor f =>
    Getting (Traversed r f) s a -> (a -> f r) -> s -> f ()
    traverseOf_
    {-# INLINE forOf_ #-}

    -- | Evaluate each action in observed by a 'Fold' on a structure from left to right, ignoring the results.
    --
    -- @
    -- 'sequenceA_' ≡ 'sequenceAOf_' 'folded'
    -- @
    --
    -- >>> sequenceAOf_ both (putStrLn "hello",putStrLn "world")
    -- hello
    -- world
    --
    -- @
    -- 'sequenceAOf_' :: 'Functor' f     => 'Getter' s (f a)     -> s -> f ()
    -- 'sequenceAOf_' :: 'Applicative' f => 'Fold' s (f a)       -> s -> f ()
    -- 'sequenceAOf_' :: 'Functor' f     => 'Lens'' s (f a)      -> s -> f ()
    -- 'sequenceAOf_' :: 'Functor' f     => 'Iso'' s (f a)       -> s -> f ()
    -- 'sequenceAOf_' :: 'Applicative' f => 'Traversal'' s (f a) -> s -> f ()
    -- 'sequenceAOf_' :: 'Applicative' f => 'Prism'' s (f a)     -> s -> f ()
    -- @
    sequenceAOf_ :: Functor f => Getting (Traversed a f) s (f a) -> s -> f ()
    sequenceAOf_ :: forall (f :: * -> *) a s.
    Functor f =>
    Getting (Traversed a f) s (f a) -> s -> f ()
    sequenceAOf_ Getting (Traversed a f) s (f a)
    l = f a -> f ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (f a -> f ()) -> (s -> f a) -> s -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Traversed a f -> f a
    forall a (f :: * -> *). Traversed a f -> f a
    getTraversed (Traversed a f -> f a) -> (s -> Traversed a f) -> s -> f a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (Traversed a f) s (f a)
    -> (f a -> Traversed a f) -> s -> Traversed a f
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Traversed a f) s (f a)
    l f a -> Traversed a f
    forall a (f :: * -> *). f a -> Traversed a f
    Traversed
    {-# INLINE sequenceAOf_ #-}

    -- | Traverse over all of the targets of a 'Fold1', computing an 'Apply' based answer.
    --
    -- As long as you have 'Applicative' or 'Functor' effect you are better using 'traverseOf_'.
    -- The 'traverse1Of_' is useful only when you have genuine 'Apply' effect.
    --
    -- >>> traverse1Of_ both1 (\ks -> Map.fromList [ (k, ()) | k <- ks ]) ("abc", "bcd")
    -- fromList [('b',()),('c',())]
    --
    -- @
    -- 'traverse1Of_' :: 'Apply' f => 'Fold1' s a -> (a -> f r) -> s -> f ()
    -- @
    --
    -- @since 4.16
    traverse1Of_ :: Functor f => Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
    traverse1Of_ :: forall (f :: * -> *) r s a.
    Functor f =>
    Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
    traverse1Of_ Getting (TraversedF r f) s a
    l a -> f r
    f = f r -> f ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (f r -> f ()) -> (s -> f r) -> s -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TraversedF r f -> f r
    forall a (f :: * -> *). TraversedF a f -> f a
    getTraversedF (TraversedF r f -> f r) -> (s -> TraversedF r f) -> s -> f r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (TraversedF r f) s a
    -> (a -> TraversedF r f) -> s -> TraversedF r f
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (TraversedF r f) s a
    l (f r -> TraversedF r f
    forall a (f :: * -> *). f a -> TraversedF a f
    TraversedF (f r -> TraversedF r f) -> (a -> f r) -> a -> TraversedF r f
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> f r
    f)
    {-# INLINE traverse1Of_ #-}

    -- | See 'forOf_' and 'traverse1Of_'.
    --
    -- >>> for1Of_ both1 ("abc", "bcd") (\ks -> Map.fromList [ (k, ()) | k <- ks ])
    -- fromList [('b',()),('c',())]
    --
    -- @
    -- 'for1Of_' :: 'Apply' f => 'Fold1' s a -> s -> (a -> f r) -> f ()
    -- @
    --
    -- @since 4.16
    for1Of_ :: Functor f => Getting (TraversedF r f) s a -> s -> (a -> f r) -> f ()
    for1Of_ :: forall (f :: * -> *) r s a.
    Functor f =>
    Getting (TraversedF r f) s a -> s -> (a -> f r) -> f ()
    for1Of_ = ((a -> f r) -> s -> f ()) -> s -> (a -> f r) -> f ()
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (((a -> f r) -> s -> f ()) -> s -> (a -> f r) -> f ())
    -> (Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ())
    -> Getting (TraversedF r f) s a
    -> s
    -> (a -> f r)
    -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
    forall (f :: * -> *) r s a.
    Functor f =>
    Getting (TraversedF r f) s a -> (a -> f r) -> s -> f ()
    traverse1Of_
    {-# INLINE for1Of_ #-}

    -- | See 'sequenceAOf_' and 'traverse1Of_'.
    --
    -- @
    -- 'sequence1Of_' :: 'Apply' f => 'Fold1' s (f a) -> s -> f ()
    -- @
    --
    -- @since 4.16
    sequence1Of_ :: Functor f => Getting (TraversedF a f) s (f a) -> s -> f ()
    sequence1Of_ :: forall (f :: * -> *) a s.
    Functor f =>
    Getting (TraversedF a f) s (f a) -> s -> f ()
    sequence1Of_ Getting (TraversedF a f) s (f a)
    l = f a -> f ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (f a -> f ()) -> (s -> f a) -> s -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . TraversedF a f -> f a
    forall a (f :: * -> *). TraversedF a f -> f a
    getTraversedF (TraversedF a f -> f a) -> (s -> TraversedF a f) -> s -> f a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (TraversedF a f) s (f a)
    -> (f a -> TraversedF a f) -> s -> TraversedF a f
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (TraversedF a f) s (f a)
    l f a -> TraversedF a f
    forall a (f :: * -> *). f a -> TraversedF a f
    TraversedF
    {-# INLINE sequence1Of_ #-}

    -- | Map each target of a 'Fold' on a structure to a monadic action, evaluate these actions from left to right, and ignore the results.
    --
    -- >>> mapMOf_ both putStrLn ("hello","world")
    -- hello
    -- world
    --
    -- @
    -- 'Data.Foldable.mapM_' ≡ 'mapMOf_' 'folded'
    -- @
    --
    -- @
    -- 'mapMOf_' :: 'Monad' m => 'Getter' s a     -> (a -> m r) -> s -> m ()
    -- 'mapMOf_' :: 'Monad' m => 'Fold' s a       -> (a -> m r) -> s -> m ()
    -- 'mapMOf_' :: 'Monad' m => 'Lens'' s a      -> (a -> m r) -> s -> m ()
    -- 'mapMOf_' :: 'Monad' m => 'Iso'' s a       -> (a -> m r) -> s -> m ()
    -- 'mapMOf_' :: 'Monad' m => 'Traversal'' s a -> (a -> m r) -> s -> m ()
    -- 'mapMOf_' :: 'Monad' m => 'Prism'' s a     -> (a -> m r) -> s -> m ()
    -- @
    mapMOf_ :: Monad m => Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
    mapMOf_ :: forall (m :: * -> *) r s a.
    Monad m =>
    Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
    mapMOf_ Getting (Sequenced r m) s a
    l a -> m r
    f = (r -> ()) -> m r -> m ()
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM r -> ()
    forall a. a -> ()
    skip (m r -> m ()) -> (s -> m r) -> s -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Sequenced r m -> m r
    forall a (m :: * -> *). Sequenced a m -> m a
    getSequenced (Sequenced r m -> m r) -> (s -> Sequenced r m) -> s -> m r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (Sequenced r m) s a
    -> (a -> Sequenced r m) -> s -> Sequenced r m
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Sequenced r m) s a
    l (m r -> Sequenced r m
    forall a (m :: * -> *). m a -> Sequenced a m
    Sequenced (m r -> Sequenced r m) -> (a -> m r) -> a -> Sequenced r m
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> m r
    f)
    {-# INLINE mapMOf_ #-}

    -- | 'forMOf_' is 'mapMOf_' with two of its arguments flipped.
    --
    -- >>> forMOf_ both ("hello","world") putStrLn
    -- hello
    -- world
    --
    -- @
    -- 'Data.Foldable.forM_' ≡ 'forMOf_' 'folded'
    -- @
    --
    -- @
    -- 'forMOf_' :: 'Monad' m => 'Getter' s a     -> s -> (a -> m r) -> m ()
    -- 'forMOf_' :: 'Monad' m => 'Fold' s a       -> s -> (a -> m r) -> m ()
    -- 'forMOf_' :: 'Monad' m => 'Lens'' s a      -> s -> (a -> m r) -> m ()
    -- 'forMOf_' :: 'Monad' m => 'Iso'' s a       -> s -> (a -> m r) -> m ()
    -- 'forMOf_' :: 'Monad' m => 'Traversal'' s a -> s -> (a -> m r) -> m ()
    -- 'forMOf_' :: 'Monad' m => 'Prism'' s a     -> s -> (a -> m r) -> m ()
    -- @
    forMOf_ :: Monad m => Getting (Sequenced r m) s a -> s -> (a -> m r) -> m ()
    forMOf_ :: forall (m :: * -> *) r s a.
    Monad m =>
    Getting (Sequenced r m) s a -> s -> (a -> m r) -> m ()
    forMOf_ = ((a -> m r) -> s -> m ()) -> s -> (a -> m r) -> m ()
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (((a -> m r) -> s -> m ()) -> s -> (a -> m r) -> m ())
    -> (Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ())
    -> Getting (Sequenced r m) s a
    -> s
    -> (a -> m r)
    -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
    forall (m :: * -> *) r s a.
    Monad m =>
    Getting (Sequenced r m) s a -> (a -> m r) -> s -> m ()
    mapMOf_
    {-# INLINE forMOf_ #-}

    -- | Evaluate each monadic action referenced by a 'Fold' on the structure from left to right, and ignore the results.
    --
    -- >>> sequenceOf_ both (putStrLn "hello",putStrLn "world")
    -- hello
    -- world
    --
    -- @
    -- 'Data.Foldable.sequence_' ≡ 'sequenceOf_' 'folded'
    -- @
    --
    -- @
    -- 'sequenceOf_' :: 'Monad' m => 'Getter' s (m a)     -> s -> m ()
    -- 'sequenceOf_' :: 'Monad' m => 'Fold' s (m a)       -> s -> m ()
    -- 'sequenceOf_' :: 'Monad' m => 'Lens'' s (m a)      -> s -> m ()
    -- 'sequenceOf_' :: 'Monad' m => 'Iso'' s (m a)       -> s -> m ()
    -- 'sequenceOf_' :: 'Monad' m => 'Traversal'' s (m a) -> s -> m ()
    -- 'sequenceOf_' :: 'Monad' m => 'Prism'' s (m a)     -> s -> m ()
    -- @
    sequenceOf_ :: Monad m => Getting (Sequenced a m) s (m a) -> s -> m ()
    sequenceOf_ :: forall (m :: * -> *) a s.
    Monad m =>
    Getting (Sequenced a m) s (m a) -> s -> m ()
    sequenceOf_ Getting (Sequenced a m) s (m a)
    l = (a -> ()) -> m a -> m ()
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> ()
    forall a. a -> ()
    skip (m a -> m ()) -> (s -> m a) -> s -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Sequenced a m -> m a
    forall a (m :: * -> *). Sequenced a m -> m a
    getSequenced (Sequenced a m -> m a) -> (s -> Sequenced a m) -> s -> m a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (Sequenced a m) s (m a)
    -> (m a -> Sequenced a m) -> s -> Sequenced a m
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Sequenced a m) s (m a)
    l m a -> Sequenced a m
    forall a (m :: * -> *). m a -> Sequenced a m
    Sequenced
    {-# INLINE sequenceOf_ #-}

    -- | The sum of a collection of actions, generalizing 'concatOf'.
    --
    -- >>> asumOf both ("hello","world")
    -- "helloworld"
    --
    -- >>> asumOf each (Nothing, Just "hello", Nothing)
    -- Just "hello"
    --
    -- @
    -- 'asum' ≡ 'asumOf' 'folded'
    -- @
    --
    -- @
    -- 'asumOf' :: 'Alternative' f => 'Getter' s (f a)     -> s -> f a
    -- 'asumOf' :: 'Alternative' f => 'Fold' s (f a)       -> s -> f a
    -- 'asumOf' :: 'Alternative' f => 'Lens'' s (f a)      -> s -> f a
    -- 'asumOf' :: 'Alternative' f => 'Iso'' s (f a)       -> s -> f a
    -- 'asumOf' :: 'Alternative' f => 'Traversal'' s (f a) -> s -> f a
    -- 'asumOf' :: 'Alternative' f => 'Prism'' s (f a)     -> s -> f a
    -- @
    asumOf :: Alternative f => Getting (Endo (f a)) s (f a) -> s -> f a
    asumOf :: forall (f :: * -> *) a s.
    Alternative f =>
    Getting (Endo (f a)) s (f a) -> s -> f a
    asumOf Getting (Endo (f a)) s (f a)
    l = Getting (Endo (f a)) s (f a)
    -> (f a -> f a -> f a) -> f a -> s -> f a
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (f a)) s (f a)
    l f a -> f a -> f a
    forall a. f a -> f a -> f a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    (<|>) f a
    forall a. f a
    forall (f :: * -> *) a. Alternative f => f a
    empty
    {-# INLINE asumOf #-}

    -- | The sum of a collection of actions, generalizing 'concatOf'.
    --
    -- >>> msumOf both ("hello","world")
    -- "helloworld"
    --
    -- >>> msumOf each (Nothing, Just "hello", Nothing)
    -- Just "hello"
    --
    -- @
    -- 'msum' ≡ 'msumOf' 'folded'
    -- @
    --
    -- @
    -- 'msumOf' :: 'MonadPlus' m => 'Getter' s (m a)     -> s -> m a
    -- 'msumOf' :: 'MonadPlus' m => 'Fold' s (m a)       -> s -> m a
    -- 'msumOf' :: 'MonadPlus' m => 'Lens'' s (m a)      -> s -> m a
    -- 'msumOf' :: 'MonadPlus' m => 'Iso'' s (m a)       -> s -> m a
    -- 'msumOf' :: 'MonadPlus' m => 'Traversal'' s (m a) -> s -> m a
    -- 'msumOf' :: 'MonadPlus' m => 'Prism'' s (m a)     -> s -> m a
    -- @
    msumOf :: MonadPlus m => Getting (Endo (m a)) s (m a) -> s -> m a
    msumOf :: forall (m :: * -> *) a s.
    MonadPlus m =>
    Getting (Endo (m a)) s (m a) -> s -> m a
    msumOf Getting (Endo (m a)) s (m a)
    l = Getting (Endo (m a)) s (m a)
    -> (m a -> m a -> m a) -> m a -> s -> m a
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (m a)) s (m a)
    l m a -> m a -> m a
    forall a. m a -> m a -> m a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    mplus m a
    forall a. m a
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero
    {-# INLINE msumOf #-}

    -- | Does the element occur anywhere within a given 'Fold' of the structure?
    --
    -- >>> elemOf both "hello" ("hello","world")
    -- True
    --
    -- @
    -- 'elem' ≡ 'elemOf' 'folded'
    -- @
    --
    -- @
    -- 'elemOf' :: 'Eq' a => 'Getter' s a     -> a -> s -> 'Bool'
    -- 'elemOf' :: 'Eq' a => 'Fold' s a       -> a -> s -> 'Bool'
    -- 'elemOf' :: 'Eq' a => 'Lens'' s a      -> a -> s -> 'Bool'
    -- 'elemOf' :: 'Eq' a => 'Iso'' s a       -> a -> s -> 'Bool'
    -- 'elemOf' :: 'Eq' a => 'Traversal'' s a -> a -> s -> 'Bool'
    -- 'elemOf' :: 'Eq' a => 'Prism'' s a     -> a -> s -> 'Bool'
    -- @
    elemOf :: Eq a => Getting Any s a -> a -> s -> Bool
    elemOf :: forall a s. Eq a => Getting Any s a -> a -> s -> Bool
    elemOf Getting Any s a
    l = Getting Any s a -> (a -> Bool) -> s -> Bool
    forall s a. Getting Any s a -> (a -> Bool) -> s -> Bool
    anyOf Getting Any s a
    l ((a -> Bool) -> s -> Bool) -> (a -> a -> Bool) -> a -> s -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    (==)
    {-# INLINE elemOf #-}

    -- | 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'
    -- @
    --
    -- @
    -- 'notElemOf' :: 'Eq' a => 'Getter' s a     -> a -> s -> 'Bool'
    -- 'notElemOf' :: 'Eq' a => 'Fold' s a       -> a -> s -> 'Bool'
    -- 'notElemOf' :: 'Eq' a => 'Iso'' s a       -> a -> s -> 'Bool'
    -- 'notElemOf' :: 'Eq' a => 'Lens'' s a      -> a -> s -> 'Bool'
    -- 'notElemOf' :: 'Eq' a => 'Traversal'' s a -> a -> s -> 'Bool'
    -- 'notElemOf' :: 'Eq' a => 'Prism'' s a     -> a -> s -> 'Bool'
    -- @
    notElemOf :: Eq a => Getting All s a -> a -> s -> Bool
    notElemOf :: forall a s. Eq a => Getting All s a -> a -> s -> Bool
    notElemOf Getting All s a
    l = Getting All s a -> (a -> Bool) -> s -> Bool
    forall s a. Getting All s a -> (a -> Bool) -> s -> Bool
    allOf Getting All s a
    l ((a -> Bool) -> s -> Bool) -> (a -> a -> Bool) -> a -> s -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    (/=)
    {-# INLINE notElemOf #-}

    -- | Map a function over all the targets of a 'Fold' of a container and concatenate the resulting lists.
    --
    -- >>> concatMapOf both (\x -> [x, x + 1]) (1,3)
    -- [1,2,3,4]
    --
    -- @
    -- 'concatMap' ≡ 'concatMapOf' 'folded'
    -- @
    --
    -- @
    -- 'concatMapOf' :: 'Getter' s a     -> (a -> [r]) -> s -> [r]
    -- 'concatMapOf' :: 'Fold' s a       -> (a -> [r]) -> s -> [r]
    -- 'concatMapOf' :: 'Lens'' s a      -> (a -> [r]) -> s -> [r]
    -- 'concatMapOf' :: 'Iso'' s a       -> (a -> [r]) -> s -> [r]
    -- 'concatMapOf' :: 'Traversal'' s a -> (a -> [r]) -> s -> [r]
    -- @
    concatMapOf :: Getting [r] s a -> (a -> [r]) -> s -> [r]
    concatMapOf :: forall r s a. Getting [r] s a -> (a -> [r]) -> s -> [r]
    concatMapOf = Getting [r] s a -> (a -> [r]) -> s -> [r]
    forall a b. Coercible a b => a -> b
    coerce
    {-# INLINE concatMapOf #-}

    -- | Concatenate all of the lists targeted by a 'Fold' into a longer list.
    --
    -- >>> concatOf both ("pan","ama")
    -- "panama"
    --
    -- @
    -- 'concat' ≡ 'concatOf' 'folded'
    -- 'concatOf' ≡ 'view'
    -- @
    --
    -- @
    -- 'concatOf' :: 'Getter' s [r]     -> s -> [r]
    -- 'concatOf' :: 'Fold' s [r]       -> s -> [r]
    -- 'concatOf' :: 'Iso'' s [r]       -> s -> [r]
    -- 'concatOf' :: 'Lens'' s [r]      -> s -> [r]
    -- 'concatOf' :: 'Traversal'' s [r] -> s -> [r]
    -- @
    concatOf :: Getting [r] s [r] -> s -> [r]
    concatOf :: forall r s. Getting [r] s [r] -> s -> [r]
    concatOf Getting [r] s [r]
    l = Const [r] s -> [r]
    forall {k} a (b :: k). Const a b -> a
    getConst (Const [r] s -> [r]) -> (s -> Const [r] s) -> s -> [r]
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting [r] s [r]
    l [r] -> Const [r] [r]
    forall {k} a (b :: k). a -> Const a b
    Const
    {-# INLINE concatOf #-}

    -- | 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 traverse [1..10]
    -- 10
    --
    -- >>> lengthOf (traverse.traverse) [[1,2],[3,4],[5,6]]
    -- 6
    --
    -- @
    -- 'lengthOf' ('folded' '.' 'folded') :: ('Foldable' f, 'Foldable' g) => f (g a) -> 'Int'
    -- @
    --
    -- @
    -- 'lengthOf' :: 'Getter' s a     -> s -> 'Int'
    -- 'lengthOf' :: 'Fold' s a       -> s -> 'Int'
    -- 'lengthOf' :: 'Lens'' s a      -> s -> 'Int'
    -- 'lengthOf' :: 'Iso'' s a       -> s -> 'Int'
    -- 'lengthOf' :: 'Traversal'' s a -> s -> 'Int'
    -- @
    lengthOf :: Getting (Endo (Endo Int)) s a -> s -> Int
    lengthOf :: forall s a. Getting (Endo (Endo Int)) s a -> s -> Int
    lengthOf Getting (Endo (Endo Int)) s a
    l = Getting (Endo (Endo Int)) s a
    -> (Int -> a -> Int) -> Int -> s -> Int
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo Int)) s a
    l (\Int
    a a
    _ -> Int
    a Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) Int
    0
    {-# INLINE lengthOf #-}

    -- | 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.
    --
    -- Note: if you get stack overflows due to this, you may want to use 'firstOf' instead, which can deal
    -- more gracefully with heavily left-biased trees. This is because '^?' works by using the
    -- 'Data.Monoid.First' monoid, which can occasionally cause space leaks.
    --
    -- >>> Left 4 ^?_Left
    -- Just 4
    --
    -- >>> Right 4 ^?_Left
    -- Nothing
    --
    -- >>> "world" ^? ix 3
    -- Just 'l'
    --
    -- >>> "world" ^? ix 20
    -- Nothing
    --
    -- This operator works as an infix version of 'preview'.
    --
    -- @
    -- ('^?') ≡ 'flip' 'preview'
    -- @
    --
    -- It may be helpful to think of '^?' as having one of the following
    -- more specialized types:
    --
    -- @
    -- ('^?') :: s -> 'Getter' s a     -> 'Maybe' a
    -- ('^?') :: s -> 'Fold' s a       -> 'Maybe' a
    -- ('^?') :: s -> 'Lens'' s a      -> 'Maybe' a
    -- ('^?') :: s -> 'Iso'' s a       -> 'Maybe' a
    -- ('^?') :: s -> 'Traversal'' s a -> 'Maybe' a
    -- @
    (^?) :: s -> Getting (First a) s a -> Maybe a
    s
    s ^? :: forall s a. s -> Getting (First a) s a -> Maybe a
    ^? Getting (First a) s a
    l = First a -> Maybe a
    forall a. First a -> Maybe a
    getFirst (Getting (First a) s a -> (a -> First a) -> s -> First a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (First a) s a
    l (Maybe a -> First a
    forall a. Maybe a -> First a
    First (Maybe a -> First a) -> (a -> Maybe a) -> a -> First a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> Maybe a
    forall a. a -> Maybe a
    Just) s
    s)
    {-# INLINE (^?) #-}

    -- | Perform an *UNSAFE* 'head' of a 'Fold' or 'Traversal' assuming that it is there.
    --
    -- >>> Left 4 ^?! _Left
    -- 4
    --
    -- >>> "world" ^?! ix 3
    -- 'l'
    --
    -- @
    -- ('^?!') :: s -> 'Getter' s a     -> a
    -- ('^?!') :: s -> 'Fold' s a       -> a
    -- ('^?!') :: s -> 'Lens'' s a      -> a
    -- ('^?!') :: s -> 'Iso'' s a       -> a
    -- ('^?!') :: s -> 'Traversal'' s a -> a
    -- @
    (^?!) :: HasCallStack => s -> Getting (Endo a) s a -> a
    s
    s ^?! :: forall s a. HasCallStack => s -> Getting (Endo a) s a -> a
    ^?! Getting (Endo a) s a
    l = Getting (Endo a) s a -> (a -> a -> a) -> a -> s -> a
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo a) s a
    l a -> a -> a
    forall a b. a -> b -> a
    const (String -> a
    forall a. HasCallStack => String -> a
    error String
    "(^?!): empty Fold") s
    s
    {-# INLINE (^?!) #-}

    -- | Retrieve the 'First' entry of a 'Fold' or 'Traversal' or retrieve 'Just' the result
    -- from a 'Getter' or 'Lens'.
    --
    -- The answer is computed in a manner that leaks space less than @'preview'@ or @^?'@
    -- and gives you back access to the outermost 'Just' constructor more quickly, but does so
    -- in a way that builds an intermediate structure, and thus may have worse
    -- constant factors. This also means that it can not be used in any 'Control.Monad.Reader.MonadReader',
    -- but must instead have 's' passed as its last argument, unlike 'preview'.
    --
    -- Note: this could been named `headOf`.
    --
    -- >>> firstOf traverse [1..10]
    -- Just 1
    --
    -- >>> firstOf both (1,2)
    -- Just 1
    --
    -- >>> firstOf ignored ()
    -- Nothing
    --
    -- @
    -- 'firstOf' :: 'Getter' s a     -> s -> 'Maybe' a
    -- 'firstOf' :: 'Fold' s a       -> s -> 'Maybe' a
    -- 'firstOf' :: 'Lens'' s a      -> s -> 'Maybe' a
    -- 'firstOf' :: 'Iso'' s a       -> s -> 'Maybe' a
    -- 'firstOf' :: 'Traversal'' s a -> s -> 'Maybe' a
    -- @
    firstOf :: Getting (Leftmost a) s a -> s -> Maybe a
    firstOf :: forall a s. Getting (Leftmost a) s a -> s -> Maybe a
    firstOf Getting (Leftmost a) s a
    l = Leftmost a -> Maybe a
    forall a. Leftmost a -> Maybe a
    getLeftmost (Leftmost a -> Maybe a) -> (s -> Leftmost a) -> s -> Maybe a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Leftmost a) s a -> (a -> Leftmost a) -> s -> Leftmost a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Leftmost a) s a
    l a -> Leftmost a
    forall a. a -> Leftmost a
    LLeaf
    {-# INLINE firstOf #-}

    -- | Retrieve the 'Data.Semigroup.First' entry of a 'Fold1' or 'Traversal1' or the result from a 'Getter' or 'Lens'.
    --
    -- >>> first1Of traverse1 (1 :| [2..10])
    -- 1
    --
    -- >>> first1Of both1 (1,2)
    -- 1
    --
    -- /Note:/ this is different from '^.'.
    --
    -- >>> first1Of traverse1 ([1,2] :| [[3,4],[5,6]])
    -- [1,2]
    --
    -- >>> ([1,2] :| [[3,4],[5,6]]) ^. traverse1
    -- [1,2,3,4,5,6]
    --
    -- @
    -- 'first1Of' :: 'Getter' s a      -> s -> a
    -- 'first1Of' :: 'Fold1' s a       -> s -> a
    -- 'first1Of' :: 'Lens'' s a       -> s -> a
    -- 'first1Of' :: 'Iso'' s a        -> s -> a
    -- 'first1Of' :: 'Traversal1'' s a -> s -> a
    -- @
    first1Of :: Getting (Semi.First a) s a -> s -> a
    first1Of :: forall a s. Getting (First a) s a -> s -> a
    first1Of Getting (First a) s a
    l = First a -> a
    forall a. First a -> a
    Semi.getFirst (First a -> a) -> (s -> First a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (First a) s a -> (a -> First a) -> s -> First a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (First a) s a
    l a -> First a
    forall a. a -> First a
    Semi.First

    -- | Retrieve the 'Last' entry of a 'Fold' or 'Traversal' or retrieve 'Just' the result
    -- from a 'Getter' or 'Lens'.
    --
    -- The answer is computed in a manner that leaks space less than @'ala' 'Last' '.' 'foldMapOf'@
    -- and gives you back access to the outermost 'Just' constructor more quickly, but may have worse
    -- constant factors.
    --
    -- >>> lastOf traverse [1..10]
    -- Just 10
    --
    -- >>> lastOf both (1,2)
    -- Just 2
    --
    -- >>> lastOf ignored ()
    -- Nothing
    --
    -- @
    -- 'lastOf' :: 'Getter' s a     -> s -> 'Maybe' a
    -- 'lastOf' :: 'Fold' s a       -> s -> 'Maybe' a
    -- 'lastOf' :: 'Lens'' s a      -> s -> 'Maybe' a
    -- 'lastOf' :: 'Iso'' s a       -> s -> 'Maybe' a
    -- 'lastOf' :: 'Traversal'' s a -> s -> 'Maybe' a
    -- @
    lastOf :: Getting (Rightmost a) s a -> s -> Maybe a
    lastOf :: forall a s. Getting (Rightmost a) s a -> s -> Maybe a
    lastOf Getting (Rightmost a) s a
    l = Rightmost a -> Maybe a
    forall a. Rightmost a -> Maybe a
    getRightmost (Rightmost a -> Maybe a) -> (s -> Rightmost a) -> s -> Maybe a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Rightmost a) s a -> (a -> Rightmost a) -> s -> Rightmost a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Rightmost a) s a
    l a -> Rightmost a
    forall a. a -> Rightmost a
    RLeaf
    {-# INLINE lastOf #-}

    -- | Retrieve the 'Data.Semigroup.Last' entry of a 'Fold1' or 'Traversal1' or retrieve the result
    -- from a 'Getter' or 'Lens'.o
    --
    -- >>> last1Of traverse1 (1 :| [2..10])
    -- 10
    --
    -- >>> last1Of both1 (1,2)
    -- 2
    --
    -- @
    -- 'last1Of' :: 'Getter' s a      -> s -> 'Maybe' a
    -- 'last1Of' :: 'Fold1' s a       -> s -> 'Maybe' a
    -- 'last1Of' :: 'Lens'' s a       -> s -> 'Maybe' a
    -- 'last1Of' :: 'Iso'' s a        -> s -> 'Maybe' a
    -- 'last1Of' :: 'Traversal1'' s a -> s -> 'Maybe' a
    -- @
    last1Of :: Getting (Semi.Last a) s a -> s -> a
    last1Of :: forall a s. Getting (Last a) s a -> s -> a
    last1Of Getting (Last a) s a
    l = Last a -> a
    forall a. Last a -> a
    Semi.getLast (Last a -> a) -> (s -> Last a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Last a) s a -> (a -> Last a) -> s -> Last a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Last a) s a
    l a -> Last a
    forall a. a -> Last a
    Semi.Last

    -- | 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.
    --
    -- >>> nullOf _1 (1,2)
    -- False
    --
    -- >>> nullOf ignored ()
    -- True
    --
    -- >>> nullOf traverse []
    -- True
    --
    -- >>> nullOf (element 20) [1..10]
    -- True
    --
    -- @
    -- 'nullOf' ('folded' '.' '_1' '.' 'folded') :: ('Foldable' f, 'Foldable' g) => f (g a, b) -> 'Bool'
    -- @
    --
    -- @
    -- 'nullOf' :: 'Getter' s a     -> s -> 'Bool'
    -- 'nullOf' :: 'Fold' s a       -> s -> 'Bool'
    -- 'nullOf' :: 'Iso'' s a       -> s -> 'Bool'
    -- 'nullOf' :: 'Lens'' s a      -> s -> 'Bool'
    -- 'nullOf' :: 'Traversal'' s a -> s -> 'Bool'
    -- @
    nullOf :: Getting All s a -> s -> Bool
    nullOf :: forall s a. Getting All s a -> s -> Bool
    nullOf = Getting All s a -> s -> Bool
    forall s a. Getting All s a -> s -> Bool
    hasn't
    {-# INLINE nullOf #-}

    -- | Returns 'True' if this 'Fold' or 'Traversal' has any targets in the given container.
    --
    -- A more \"conversational\" alias for this combinator is 'has'.
    --
    -- Note: 'notNullOf' on a valid 'Iso', 'Lens' or 'Getter' should always return 'True'.
    --
    -- @
    -- 'not' '.' 'null' ≡ 'notNullOf' 'folded'
    -- @
    --
    -- This may be rather inefficient compared to the @'not' '.' 'null'@ check of many containers.
    --
    -- >>> notNullOf _1 (1,2)
    -- True
    --
    -- >>> notNullOf traverse [1..10]
    -- True
    --
    -- >>> notNullOf folded []
    -- False
    --
    -- >>> notNullOf (element 20) [1..10]
    -- False
    --
    -- @
    -- 'notNullOf' ('folded' '.' '_1' '.' 'folded') :: ('Foldable' f, 'Foldable' g) => f (g a, b) -> 'Bool'
    -- @
    --
    -- @
    -- 'notNullOf' :: 'Getter' s a     -> s -> 'Bool'
    -- 'notNullOf' :: 'Fold' s a       -> s -> 'Bool'
    -- 'notNullOf' :: 'Iso'' s a       -> s -> 'Bool'
    -- 'notNullOf' :: 'Lens'' s a      -> s -> 'Bool'
    -- 'notNullOf' :: 'Traversal'' s a -> s -> 'Bool'
    -- @
    notNullOf :: Getting Any s a -> s -> Bool
    notNullOf :: forall s a. Getting Any s a -> s -> Bool
    notNullOf = Getting Any s a -> s -> Bool
    forall s a. Getting Any s a -> s -> Bool
    has
    {-# INLINE notNullOf #-}

    -- | Obtain the maximum element (if any) targeted by a 'Fold' or 'Traversal' safely.
    --
    -- Note: 'maximumOf' on a valid 'Iso', 'Lens' or 'Getter' will always return 'Just' a value.
    --
    -- >>> maximumOf traverse [1..10]
    -- Just 10
    --
    -- >>> maximumOf traverse []
    -- 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.
    -- @'rmap' 'getMax' ('foldMapOf' l 'Max')@ has lazier semantics but could leak memory.
    --
    -- @
    -- 'maximumOf' :: 'Ord' a => 'Getter' s a     -> s -> 'Maybe' a
    -- 'maximumOf' :: 'Ord' a => 'Fold' s a       -> s -> 'Maybe' a
    -- 'maximumOf' :: 'Ord' a => 'Iso'' s a       -> s -> 'Maybe' a
    -- 'maximumOf' :: 'Ord' a => 'Lens'' s a      -> s -> 'Maybe' a
    -- 'maximumOf' :: 'Ord' a => 'Traversal'' s a -> s -> 'Maybe' a
    -- @
    maximumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
    maximumOf :: forall a s.
    Ord a =>
    Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
    maximumOf Getting (Endo (Endo (Maybe a))) s a
    l = Getting (Endo (Endo (Maybe a))) s a
    -> (Maybe a -> a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo (Maybe a))) s a
    l Maybe a -> a -> Maybe a
    forall {a}. Ord a => Maybe a -> a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: Maybe a -> a -> Maybe a
    mf Maybe a
    Nothing a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a
    y
      mf (Just a
    x) a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a -> a -> a
    forall a. Ord a => a -> a -> a
    max a
    x a
    y
    {-# INLINE maximumOf #-}

    -- | Obtain the maximum element targeted by a 'Fold1' or 'Traversal1'.
    --
    -- >>> maximum1Of traverse1 (1 :| [2..10])
    -- 10
    --
    -- @
    -- 'maximum1Of' :: 'Ord' a => 'Getter' s a      -> s -> a
    -- 'maximum1Of' :: 'Ord' a => 'Fold1' s a       -> s -> a
    -- 'maximum1Of' :: 'Ord' a => 'Iso'' s a        -> s -> a
    -- 'maximum1Of' :: 'Ord' a => 'Lens'' s a       -> s -> a
    -- 'maximum1Of' :: 'Ord' a => 'Traversal1'' s a -> s -> a
    -- @
    maximum1Of :: Ord a => Getting (Semi.Max a) s a -> s -> a
    maximum1Of :: forall a s. Ord a => Getting (Max a) s a -> s -> a
    maximum1Of Getting (Max a) s a
    l = Max a -> a
    forall a. Max a -> a
    Semi.getMax (Max a -> a) -> (s -> Max a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Max a) s a -> (a -> Max a) -> s -> Max a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Max a) s a
    l a -> Max a
    forall a. a -> Max a
    Semi.Max
    {-# INLINE maximum1Of #-}

    -- | Obtain the minimum element (if any) targeted by a 'Fold' or 'Traversal' safely.
    --
    -- Note: 'minimumOf' on a valid 'Iso', 'Lens' or 'Getter' will always return 'Just' a value.
    --
    -- >>> minimumOf traverse [1..10]
    -- Just 1
    --
    -- >>> minimumOf traverse []
    -- Nothing
    --
    -- >>> minimumOf (folded.filtered even) [1,4,3,6,7,9,2]
    -- Just 2
    --
    -- @
    -- 'minimum' ≡ 'Data.Maybe.fromMaybe' ('error' \"empty\") '.' 'minimumOf' 'folded'
    -- @
    --
    -- In the interest of efficiency, This operation has semantics more strict than strictly necessary.
    -- @'rmap' 'getMin' ('foldMapOf' l 'Min')@ has lazier semantics but could leak memory.
    --
    --
    -- @
    -- 'minimumOf' :: 'Ord' a => 'Getter' s a     -> s -> 'Maybe' a
    -- 'minimumOf' :: 'Ord' a => 'Fold' s a       -> s -> 'Maybe' a
    -- 'minimumOf' :: 'Ord' a => 'Iso'' s a       -> s -> 'Maybe' a
    -- 'minimumOf' :: 'Ord' a => 'Lens'' s a      -> s -> 'Maybe' a
    -- 'minimumOf' :: 'Ord' a => 'Traversal'' s a -> s -> 'Maybe' a
    -- @
    minimumOf :: Ord a => Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
    minimumOf :: forall a s.
    Ord a =>
    Getting (Endo (Endo (Maybe a))) s a -> s -> Maybe a
    minimumOf Getting (Endo (Endo (Maybe a))) s a
    l = Getting (Endo (Endo (Maybe a))) s a
    -> (Maybe a -> a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo (Maybe a))) s a
    l Maybe a -> a -> Maybe a
    forall {a}. Ord a => Maybe a -> a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: Maybe a -> a -> Maybe a
    mf Maybe a
    Nothing a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a
    y
      mf (Just a
    x) a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a -> a -> a
    forall a. Ord a => a -> a -> a
    min a
    x a
    y
    {-# INLINE minimumOf #-}

    -- | Obtain the minimum element targeted by a 'Fold1' or 'Traversal1'.
    --
    -- >>> minimum1Of traverse1 (1 :| [2..10])
    -- 1
    --
    -- @
    -- 'minimum1Of' :: 'Ord' a => 'Getter' s a      -> s -> a
    -- 'minimum1Of' :: 'Ord' a => 'Fold1' s a       -> s -> a
    -- 'minimum1Of' :: 'Ord' a => 'Iso'' s a        -> s -> a
    -- 'minimum1Of' :: 'Ord' a => 'Lens'' s a       -> s -> a
    -- 'minimum1Of' :: 'Ord' a => 'Traversal1'' s a -> s -> a
    -- @
    minimum1Of :: Ord a => Getting (Semi.Min a) s a -> s -> a
    minimum1Of :: forall a s. Ord a => Getting (Min a) s a -> s -> a
    minimum1Of Getting (Min a) s a
    l = Min a -> a
    forall a. Min a -> a
    Semi.getMin (Min a -> a) -> (s -> Min a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Min a) s a -> (a -> Min a) -> s -> Min a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (Min a) s a
    l a -> Min a
    forall a. a -> Min a
    Semi.Min
    {-# INLINE minimum1Of #-}

    -- | Obtain the maximum element (if any) targeted by a 'Fold', 'Traversal', 'Lens', 'Iso',
    -- or 'Getter' according to a user supplied 'Ordering'.
    --
    -- >>> maximumByOf traverse (compare `on` length) ["mustard","relish","ham"]
    -- Just "mustard"
    --
    -- In the interest of efficiency, This operation has semantics more strict than strictly necessary.
    --
    -- @
    -- 'Data.Foldable.maximumBy' cmp ≡ 'Data.Maybe.fromMaybe' ('error' \"empty\") '.' 'maximumByOf' 'folded' cmp
    -- @
    --
    -- @
    -- 'maximumByOf' :: 'Getter' s a     -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'maximumByOf' :: 'Fold' s a       -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'maximumByOf' :: 'Iso'' s a       -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'maximumByOf' :: 'Lens'' s a      -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'maximumByOf' :: 'Traversal'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- @
    maximumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
    maximumByOf :: forall a s.
    Getting (Endo (Endo (Maybe a))) s a
    -> (a -> a -> Ordering) -> s -> Maybe a
    maximumByOf Getting (Endo (Endo (Maybe a))) s a
    l a -> a -> Ordering
    cmp = Getting (Endo (Endo (Maybe a))) s a
    -> (Maybe a -> a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo (Maybe a))) s a
    l Maybe a -> a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: Maybe a -> a -> Maybe a
    mf Maybe a
    Nothing a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a
    y
      mf (Just a
    x) a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! if a -> a -> Ordering
    cmp a
    x a
    y Ordering -> Ordering -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ordering
    GT then a
    x else a
    y
    {-# INLINE maximumByOf #-}

    -- | Obtain the minimum element (if any) targeted by a 'Fold', 'Traversal', 'Lens', 'Iso'
    -- or 'Getter' according to a user supplied 'Ordering'.
    --
    -- In the interest of efficiency, This operation has semantics more strict than strictly necessary.
    --
    -- >>> minimumByOf traverse (compare `on` length) ["mustard","relish","ham"]
    -- Just "ham"
    --
    -- @
    -- 'minimumBy' cmp ≡ 'Data.Maybe.fromMaybe' ('error' \"empty\") '.' 'minimumByOf' 'folded' cmp
    -- @
    --
    -- @
    -- 'minimumByOf' :: 'Getter' s a     -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'minimumByOf' :: 'Fold' s a       -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'minimumByOf' :: 'Iso'' s a       -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'minimumByOf' :: 'Lens'' s a      -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- 'minimumByOf' :: 'Traversal'' s a -> (a -> a -> 'Ordering') -> s -> 'Maybe' a
    -- @
    minimumByOf :: Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> Ordering) -> s -> Maybe a
    minimumByOf :: forall a s.
    Getting (Endo (Endo (Maybe a))) s a
    -> (a -> a -> Ordering) -> s -> Maybe a
    minimumByOf Getting (Endo (Endo (Maybe a))) s a
    l a -> a -> Ordering
    cmp = Getting (Endo (Endo (Maybe a))) s a
    -> (Maybe a -> a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo (Maybe a))) s a
    l Maybe a -> a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: Maybe a -> a -> Maybe a
    mf Maybe a
    Nothing a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a
    y
      mf (Just a
    x) a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! if a -> a -> Ordering
    cmp a
    x a
    y Ordering -> Ordering -> Bool
    forall a. Eq a => a -> a -> Bool
    == Ordering
    GT then a
    y else a
    x
    {-# INLINE minimumByOf #-}

    -- | 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 each even (1,3,4,6)
    -- Just 4
    --
    -- >>> findOf folded even [1,3,5,7]
    -- Nothing
    --
    -- @
    -- 'findOf' :: 'Getter' s a     -> (a -> 'Bool') -> s -> 'Maybe' a
    -- 'findOf' :: 'Fold' s a       -> (a -> 'Bool') -> s -> 'Maybe' a
    -- 'findOf' :: 'Iso'' s a       -> (a -> 'Bool') -> s -> 'Maybe' a
    -- 'findOf' :: 'Lens'' s a      -> (a -> 'Bool') -> s -> 'Maybe' a
    -- 'findOf' :: 'Traversal'' s a -> (a -> 'Bool') -> s -> 'Maybe' a
    -- @
    --
    -- @
    -- 'Data.Foldable.find' ≡ 'findOf' 'folded'
    -- 'ifindOf' l ≡ 'findOf' l '.' 'Indexed'
    -- @
    --
    -- A simpler version that didn't permit indexing, would be:
    --
    -- @
    -- 'findOf' :: 'Getting' ('Endo' ('Maybe' a)) s a -> (a -> 'Bool') -> s -> 'Maybe' a
    -- 'findOf' l p = 'foldrOf' l (\a y -> if p a then 'Just' a else y) 'Nothing'
    -- @
    findOf :: Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
    findOf :: forall a s.
    Getting (Endo (Maybe a)) s a -> (a -> Bool) -> s -> Maybe a
    findOf Getting (Endo (Maybe a)) s a
    l a -> Bool
    f = Getting (Endo (Maybe a)) s a
    -> (a -> Maybe a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (Maybe a)) s a
    l (\a
    a Maybe a
    y -> if a -> Bool
    f a
    a then a -> Maybe a
    forall a. a -> Maybe a
    Just a
    a else Maybe a
    y) Maybe a
    forall a. Maybe a
    Nothing
    {-# INLINE findOf #-}

    -- | The 'findMOf' function takes a 'Lens' (or 'Getter', 'Iso', 'Fold', or 'Traversal'),
    -- 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' :: ('Monad' m, 'Getter' s a)     -> (a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'findMOf' :: ('Monad' m, 'Fold' s a)       -> (a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'findMOf' :: ('Monad' m, 'Iso'' s a)       -> (a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'findMOf' :: ('Monad' m, 'Lens'' s a)      -> (a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'findMOf' :: ('Monad' m, 'Traversal'' s a) -> (a -> m 'Bool') -> s -> m ('Maybe' a)
    -- @
    --
    -- @
    -- 'findMOf' 'folded' :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m (Maybe a)
    -- 'ifindMOf' l ≡ 'findMOf' l '.' 'Indexed'
    -- @
    --
    -- A simpler version that didn't permit indexing, would be:
    --
    -- @
    -- 'findMOf' :: Monad m => 'Getting' ('Endo' (m ('Maybe' a))) s a -> (a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'findMOf' l p = 'foldrOf' l (\a y -> p a >>= \x -> if x then return ('Just' a) else y) $ return 'Nothing'
    -- @
    findMOf :: Monad m => Getting (Endo (m (Maybe a))) s a -> (a -> m Bool) -> s -> m (Maybe a)
    findMOf :: forall (m :: * -> *) a s.
    Monad m =>
    Getting (Endo (m (Maybe a))) s a
    -> (a -> m Bool) -> s -> m (Maybe a)
    findMOf Getting (Endo (m (Maybe a))) s a
    l a -> m Bool
    f = Getting (Endo (m (Maybe a))) s a
    -> (a -> m (Maybe a) -> m (Maybe a))
    -> m (Maybe a)
    -> s
    -> m (Maybe a)
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (m (Maybe a))) s a
    l (\a
    a m (Maybe a)
    y -> a -> m Bool
    f a
    a m Bool -> (Bool -> m (Maybe a)) -> m (Maybe a)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Bool
    r -> if Bool
    r then Maybe a -> m (Maybe a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    a) else m (Maybe a)
    y) (m (Maybe a) -> s -> m (Maybe a))
    -> m (Maybe a) -> s -> m (Maybe a)
    forall a b. (a -> b) -> a -> b
    $ Maybe a -> m (Maybe a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe a
    forall a. Maybe a
    Nothing
    {-# INLINE findMOf #-}

    -- | The 'lookupOf' function takes a 'Fold' (or 'Getter', 'Traversal',
    -- 'Lens', 'Iso', etc.), 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 each 2 [(2, 'a'), (4, 'b'), (4, 'c')]
    -- Just 'a'
    --
    -- @
    -- 'lookupOf' :: 'Eq' k => 'Fold' s (k,v) -> k -> s -> 'Maybe' v
    -- @
    lookupOf :: Eq k => Getting (Endo (Maybe v)) s (k,v) -> k -> s -> Maybe v
    lookupOf :: forall k v s.
    Eq k =>
    Getting (Endo (Maybe v)) s (k, v) -> k -> s -> Maybe v
    lookupOf Getting (Endo (Maybe v)) s (k, v)
    l k
    k = Getting (Endo (Maybe v)) s (k, v)
    -> ((k, v) -> Maybe v -> Maybe v) -> Maybe v -> s -> Maybe v
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (Maybe v)) s (k, v)
    l (\(k
    k',v
    v) Maybe v
    next -> if k
    k k -> k -> Bool
    forall a. Eq a => a -> a -> Bool
    == k
    k' then v -> Maybe v
    forall a. a -> Maybe a
    Just v
    v else Maybe v
    next) Maybe v
    forall a. Maybe a
    Nothing
    {-# INLINE lookupOf #-}

    -- | 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 each (+) (1,2,3,4)
    -- 10
    --
    -- @
    -- 'foldr1Of' l f ≡ 'Prelude.foldr1' f '.' 'toListOf' l
    -- 'Data.Foldable.foldr1' ≡ 'foldr1Of' 'folded'
    -- @
    --
    -- @
    -- 'foldr1Of' :: 'Getter' s a     -> (a -> a -> a) -> s -> a
    -- 'foldr1Of' :: 'Fold' s a       -> (a -> a -> a) -> s -> a
    -- 'foldr1Of' :: 'Iso'' s a       -> (a -> a -> a) -> s -> a
    -- 'foldr1Of' :: 'Lens'' s a      -> (a -> a -> a) -> s -> a
    -- 'foldr1Of' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
    -- @
    foldr1Of :: HasCallStack => Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
    -- See: NOTE: [Inlining and arity]
    foldr1Of :: forall a s.
    HasCallStack =>
    Getting (Endo (Maybe a)) s a -> (a -> a -> a) -> s -> a
    foldr1Of Getting (Endo (Maybe a)) s a
    l a -> a -> a
    f = a -> Maybe a -> a
    forall a. a -> Maybe a -> a
    fromMaybe (String -> a
    forall a. HasCallStack => String -> a
    error String
    "foldr1Of: empty structure")
                 (Maybe a -> a) -> (s -> Maybe a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Endo (Maybe a)) s a
    -> (a -> Maybe a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (Maybe a)) s a
    l a -> Maybe a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: a -> Maybe a -> Maybe a
    mf a
    x Maybe a
    my = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $ case Maybe a
    my of
        Maybe a
    Nothing -> a
    x
        Just a
    y -> a -> a -> a
    f a
    x a
    y
    {-# INLINE foldr1Of #-}

    -- | A variant of 'foldlOf' 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.
    --
    -- >>> foldl1Of each (+) (1,2,3,4)
    -- 10
    --
    -- @
    -- 'foldl1Of' l f ≡ 'Prelude.foldl1' f '.' 'toListOf' l
    -- 'Data.Foldable.foldl1' ≡ 'foldl1Of' 'folded'
    -- @
    --
    -- @
    -- 'foldl1Of' :: 'Getter' s a     -> (a -> a -> a) -> s -> a
    -- 'foldl1Of' :: 'Fold' s a       -> (a -> a -> a) -> s -> a
    -- 'foldl1Of' :: 'Iso'' s a       -> (a -> a -> a) -> s -> a
    -- 'foldl1Of' :: 'Lens'' s a      -> (a -> a -> a) -> s -> a
    -- 'foldl1Of' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
    -- @
    foldl1Of :: HasCallStack => Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
    -- See: NOTE: [Inlining and arity]
    foldl1Of :: forall a s.
    HasCallStack =>
    Getting (Dual (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
    foldl1Of Getting (Dual (Endo (Maybe a))) s a
    l a -> a -> a
    f = a -> Maybe a -> a
    forall a. a -> Maybe a -> a
    fromMaybe (String -> a
    forall a. HasCallStack => String -> a
    error String
    "foldl1Of: empty structure") (Maybe a -> a) -> (s -> Maybe a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Dual (Endo (Maybe a))) s a
    -> (Maybe a -> a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a.
    Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf Getting (Dual (Endo (Maybe a))) s a
    l Maybe a -> a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: Maybe a -> a -> Maybe a
    mf Maybe a
    mx a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $ case Maybe a
    mx of
        Maybe a
    Nothing -> a
    y
        Just a
    x  -> a -> a -> a
    f a
    x a
    y
    {-# INLINE foldl1Of #-}

    -- | Strictly fold right over the elements of a structure.
    --
    -- @
    -- 'Data.Foldable.foldr'' ≡ 'foldrOf'' 'folded'
    -- @
    --
    -- @
    -- 'foldrOf'' :: 'Getter' s a     -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf'' :: 'Fold' s a       -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf'' :: 'Iso'' s a       -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf'' :: 'Lens'' s a      -> (a -> r -> r) -> r -> s -> r
    -- 'foldrOf'' :: 'Traversal'' s a -> (a -> r -> r) -> r -> s -> r
    -- @
    foldrOf' :: Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
    -- See: NOTE: [Inlining and arity]
    foldrOf' :: forall r s a.
    Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf' Getting (Dual (Endo (Endo r))) s a
    l a -> r -> r
    f r
    z0 = \s
    xs -> Getting (Dual (Endo (Endo r))) s a
    -> (Endo r -> a -> Endo r) -> Endo r -> s -> Endo r
    forall r s a.
    Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf Getting (Dual (Endo (Endo r))) s a
    l Endo r -> a -> Endo r
    f' ((r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo r -> r
    forall a. a -> a
    id) s
    xs Endo r -> r -> r
    forall a. Endo a -> a -> a
    `appEndo` r
    z0
      where f' :: Endo r -> a -> Endo r
    f' (Endo r -> r
    k) a
    x = (r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo ((r -> r) -> Endo r) -> (r -> r) -> Endo r
    forall a b. (a -> b) -> a -> b
    $ \ r
    z -> r -> r
    k (r -> r) -> r -> r
    forall a b. (a -> b) -> a -> b
    $! a -> r -> r
    f a
    x r
    z
    {-# INLINE foldrOf' #-}

    -- | Fold over the elements of a structure, associating to the left, but strictly.
    --
    -- @
    -- 'Data.Foldable.foldl'' ≡ 'foldlOf'' 'folded'
    -- @
    --
    -- @
    -- 'foldlOf'' :: 'Getter' s a     -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf'' :: 'Fold' s a       -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf'' :: 'Iso'' s a       -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf'' :: 'Lens'' s a      -> (r -> a -> r) -> r -> s -> r
    -- 'foldlOf'' :: 'Traversal'' s a -> (r -> a -> r) -> r -> s -> r
    -- @
    foldlOf' :: Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    -- See: NOTE: [Inlining and arity]
    foldlOf' :: forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo r)) s a
    l r -> a -> r
    f r
    z0 = \s
    xs -> Getting (Endo (Endo r)) s a
    -> (a -> Endo r -> Endo r) -> Endo r -> s -> Endo r
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (Endo r)) s a
    l a -> Endo r -> Endo r
    f' ((r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo r -> r
    forall a. a -> a
    id) s
    xs Endo r -> r -> r
    forall a. Endo a -> a -> a
    `appEndo` r
    z0
      where f' :: a -> Endo r -> Endo r
    f' a
    x (Endo r -> r
    k) = (r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo ((r -> r) -> Endo r) -> (r -> r) -> Endo r
    forall a b. (a -> b) -> a -> b
    $ \r
    z -> r -> r
    k (r -> r) -> r -> r
    forall a b. (a -> b) -> a -> b
    $! r -> a -> r
    f r
    z a
    x
    {-# INLINE foldlOf' #-}

    -- | A variant of 'foldrOf'' that has no base case and thus may only be applied
    -- to folds and structures such that the fold views at least one element of the
    -- structure.
    --
    -- @
    -- 'foldr1Of' l f ≡ 'Prelude.foldr1' f '.' 'toListOf' l
    -- @
    --
    -- @
    -- 'foldr1Of'' :: 'Getter' s a     -> (a -> a -> a) -> s -> a
    -- 'foldr1Of'' :: 'Fold' s a       -> (a -> a -> a) -> s -> a
    -- 'foldr1Of'' :: 'Iso'' s a       -> (a -> a -> a) -> s -> a
    -- 'foldr1Of'' :: 'Lens'' s a      -> (a -> a -> a) -> s -> a
    -- 'foldr1Of'' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
    -- @
    foldr1Of' :: HasCallStack => Getting (Dual (Endo (Endo (Maybe a)))) s a -> (a -> a -> a) -> s -> a
    -- See: NOTE: [Inlining and arity]
    foldr1Of' :: forall a s.
    HasCallStack =>
    Getting (Dual (Endo (Endo (Maybe a)))) s a
    -> (a -> a -> a) -> s -> a
    foldr1Of' Getting (Dual (Endo (Endo (Maybe a)))) s a
    l a -> a -> a
    f = a -> Maybe a -> a
    forall a. a -> Maybe a -> a
    fromMaybe (String -> a
    forall a. HasCallStack => String -> a
    error String
    "foldr1Of': empty structure") (Maybe a -> a) -> (s -> Maybe a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Dual (Endo (Endo (Maybe a)))) s a
    -> (a -> Maybe a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a.
    Getting (Dual (Endo (Endo r))) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf' Getting (Dual (Endo (Endo (Maybe a)))) s a
    l a -> Maybe a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: a -> Maybe a -> Maybe a
    mf a
    x Maybe a
    Nothing = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a
    x
      mf a
    x (Just a
    y) = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a -> a -> a
    f a
    x a
    y
    {-# INLINE foldr1Of' #-}

    -- | A variant of 'foldlOf'' that has no base case and thus may only be applied
    -- to folds and structures such that the fold views at least one element of
    -- the structure.
    --
    -- @
    -- 'foldl1Of'' l f ≡ 'Data.List.foldl1'' f '.' 'toListOf' l
    -- @
    --
    -- @
    -- 'foldl1Of'' :: 'Getter' s a     -> (a -> a -> a) -> s -> a
    -- 'foldl1Of'' :: 'Fold' s a       -> (a -> a -> a) -> s -> a
    -- 'foldl1Of'' :: 'Iso'' s a       -> (a -> a -> a) -> s -> a
    -- 'foldl1Of'' :: 'Lens'' s a      -> (a -> a -> a) -> s -> a
    -- 'foldl1Of'' :: 'Traversal'' s a -> (a -> a -> a) -> s -> a
    -- @
    foldl1Of' :: HasCallStack => Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
    -- See: NOTE: [Inlining and arity]
    foldl1Of' :: forall a s.
    HasCallStack =>
    Getting (Endo (Endo (Maybe a))) s a -> (a -> a -> a) -> s -> a
    foldl1Of' Getting (Endo (Endo (Maybe a))) s a
    l a -> a -> a
    f = a -> Maybe a -> a
    forall a. a -> Maybe a -> a
    fromMaybe (String -> a
    forall a. HasCallStack => String -> a
    error String
    "foldl1Of': empty structure") (Maybe a -> a) -> (s -> Maybe a) -> s -> a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (Endo (Endo (Maybe a))) s a
    -> (Maybe a -> a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall r s a.
    Getting (Endo (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf' Getting (Endo (Endo (Maybe a))) s a
    l Maybe a -> a -> Maybe a
    mf Maybe a
    forall a. Maybe a
    Nothing where
      mf :: Maybe a -> a -> Maybe a
    mf Maybe a
    Nothing a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a
    y
      mf (Just a
    x) a
    y = a -> Maybe a
    forall a. a -> Maybe a
    Just (a -> Maybe a) -> a -> Maybe a
    forall a b. (a -> b) -> a -> b
    $! a -> a -> a
    f a
    x a
    y
    {-# INLINE foldl1Of' #-}

    -- | Monadic fold over the elements of a structure, associating to the right,
    -- i.e. from right to left.
    --
    -- @
    -- 'Data.Foldable.foldrM' ≡ 'foldrMOf' 'folded'
    -- @
    --
    -- @
    -- 'foldrMOf' :: 'Monad' m => 'Getter' s a     -> (a -> r -> m r) -> r -> s -> m r
    -- 'foldrMOf' :: 'Monad' m => 'Fold' s a       -> (a -> r -> m r) -> r -> s -> m r
    -- 'foldrMOf' :: 'Monad' m => 'Iso'' s a       -> (a -> r -> m r) -> r -> s -> m r
    -- 'foldrMOf' :: 'Monad' m => 'Lens'' s a      -> (a -> r -> m r) -> r -> s -> m r
    -- 'foldrMOf' :: 'Monad' m => 'Traversal'' s a -> (a -> r -> m r) -> r -> s -> m r
    -- @
    foldrMOf :: Monad m
             => Getting (Dual (Endo (r -> m r))) s a
             -> (a -> r -> m r) -> r -> s -> m r
    -- See: NOTE: [Inlining and arity]
    foldrMOf :: forall (m :: * -> *) r s a.
    Monad m =>
    Getting (Dual (Endo (r -> m r))) s a
    -> (a -> r -> m r) -> r -> s -> m r
    foldrMOf Getting (Dual (Endo (r -> m r))) s a
    l a -> r -> m r
    f r
    z0 = \s
    xs -> Getting (Dual (Endo (r -> m r))) s a
    -> ((r -> m r) -> a -> r -> m r) -> (r -> m r) -> s -> r -> m r
    forall r s a.
    Getting (Dual (Endo r)) s a -> (r -> a -> r) -> r -> s -> r
    foldlOf Getting (Dual (Endo (r -> m r))) s a
    l (r -> m r) -> a -> r -> m r
    forall {b}. (r -> m b) -> a -> r -> m b
    f' r -> m r
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return s
    xs r
    z0
      where f' :: (r -> m b) -> a -> r -> m b
    f' r -> m b
    k a
    x r
    z = a -> r -> m r
    f a
    x r
    z m r -> (r -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= r -> m b
    k
    {-# INLINE foldrMOf #-}

    -- | Monadic fold over the elements of a structure, associating to the left,
    -- i.e. from left to right.
    --
    -- @
    -- 'Data.Foldable.foldlM' ≡ 'foldlMOf' 'folded'
    -- @
    --
    -- @
    -- 'foldlMOf' :: 'Monad' m => 'Getter' s a     -> (r -> a -> m r) -> r -> s -> m r
    -- 'foldlMOf' :: 'Monad' m => 'Fold' s a       -> (r -> a -> m r) -> r -> s -> m r
    -- 'foldlMOf' :: 'Monad' m => 'Iso'' s a       -> (r -> a -> m r) -> r -> s -> m r
    -- 'foldlMOf' :: 'Monad' m => 'Lens'' s a      -> (r -> a -> m r) -> r -> s -> m r
    -- 'foldlMOf' :: 'Monad' m => 'Traversal'' s a -> (r -> a -> m r) -> r -> s -> m r
    -- @
    foldlMOf :: Monad m
             => Getting (Endo (r -> m r)) s a
             -> (r -> a -> m r) -> r -> s -> m r
    -- See: NOTE: [Inlining and arity]
    foldlMOf :: forall (m :: * -> *) r s a.
    Monad m =>
    Getting (Endo (r -> m r)) s a -> (r -> a -> m r) -> r -> s -> m r
    foldlMOf Getting (Endo (r -> m r)) s a
    l r -> a -> m r
    f r
    z0 = \s
    xs -> Getting (Endo (r -> m r)) s a
    -> (a -> (r -> m r) -> r -> m r) -> (r -> m r) -> s -> r -> m r
    forall r s a. Getting (Endo r) s a -> (a -> r -> r) -> r -> s -> r
    foldrOf Getting (Endo (r -> m r)) s a
    l a -> (r -> m r) -> r -> m r
    forall {b}. a -> (r -> m b) -> r -> m b
    f' r -> m r
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return s
    xs r
    z0
      where f' :: a -> (r -> m b) -> r -> m b
    f' a
    x r -> m b
    k r
    z = r -> a -> m r
    f r
    z a
    x m r -> (r -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= r -> m b
    k
    {-# INLINE foldlMOf #-}

    -- NOTE: [Inlining and arity]
    -- ~~~~~~~~~~~~~~~~~~~~~~~~~~
    --
    -- GHC uses the following inlining heuristic: a function body is inlined if
    -- all its arguments on the LHS are applied. So the following two definitions
    -- are not equivalent from the inliner's PoV:
    --
    -- > foldlOf' l f z0 xs = ...
    -- > foldlOf' l f z0 = \xs -> ...
    --
    -- GHC will be less eager to inline the first one and this results in
    -- worse code. For example, a simple list summation using `sumOf` will be 8x slower
    -- with the first version.

    -- | Check to see if this 'Fold' or 'Traversal' matches 1 or more entries.
    --
    -- >>> has (element 0) []
    -- False
    --
    -- >>> 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
    --
    -- @
    -- 'has' :: 'Getter' s a     -> s -> 'Bool'
    -- 'has' :: 'Fold' s a       -> s -> 'Bool'
    -- 'has' :: 'Iso'' s a       -> s -> 'Bool'
    -- 'has' :: 'Lens'' s a      -> s -> 'Bool'
    -- 'has' :: 'Traversal'' s a -> s -> 'Bool'
    -- @
    has :: Getting Any s a -> s -> Bool
    has :: forall s a. Getting Any s a -> s -> Bool
    has Getting Any s a
    l = Any -> Bool
    getAny (Any -> Bool) -> (s -> Any) -> s -> Bool
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting Any s a -> (a -> Any) -> s -> Any
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting Any s a
    l (\a
    _ -> Bool -> Any
    Any Bool
    True)
    {-# INLINE has #-}

    -- | Check to see if this 'Fold' or 'Traversal' has no matches.
    --
    -- >>> hasn't _Left (Right 12)
    -- True
    --
    -- >>> hasn't _Left (Left 12)
    -- False
    hasn't :: Getting All s a -> s -> Bool
    hasn't :: forall s a. Getting All s a -> s -> Bool
    hasn't Getting All s a
    l = All -> Bool
    getAll (All -> Bool) -> (s -> All) -> s -> Bool
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting All s a -> (a -> All) -> s -> All
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting All s a
    l (\a
    _ -> Bool -> All
    All Bool
    False)
    {-# INLINE hasn't #-}

    ------------------------------------------------------------------------------
    -- Pre
    ------------------------------------------------------------------------------

    -- | This converts a 'Fold' to a 'IndexPreservingGetter' that returns the first element, if it
    -- exists, as a 'Maybe'.
    --
    -- @
    -- 'pre' :: 'Getter' s a     -> 'IndexPreservingGetter' s ('Maybe' a)
    -- 'pre' :: 'Fold' s a       -> 'IndexPreservingGetter' s ('Maybe' a)
    -- 'pre' :: 'Traversal'' s a -> 'IndexPreservingGetter' s ('Maybe' a)
    -- 'pre' :: 'Lens'' s a      -> 'IndexPreservingGetter' s ('Maybe' a)
    -- 'pre' :: 'Iso'' s a       -> 'IndexPreservingGetter' s ('Maybe' a)
    -- 'pre' :: 'Prism'' s a     -> 'IndexPreservingGetter' s ('Maybe' a)
    -- @
    pre :: Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
    pre :: forall a s.
    Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
    pre Getting (First a) s a
    l = (s -> Maybe a)
    -> (f (Maybe a) -> f s) -> p (Maybe a) (f (Maybe a)) -> p s (f s)
    forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap (First a -> Maybe a
    forall a. First a -> Maybe a
    getFirst (First a -> Maybe a) -> (s -> First a) -> s -> Maybe a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Const (First a) s -> First a
    forall {k} a (b :: k). Const a b -> a
    getConst (Const (First a) s -> First a)
    -> (s -> Const (First a) s) -> s -> First a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (First a) s a
    l (First a -> Const (First a) a
    forall {k} a (b :: k). a -> Const a b
    Const (First a -> Const (First a) a)
    -> (a -> First a) -> a -> Const (First a) a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Maybe a -> First a
    forall a. Maybe a -> First a
    First (Maybe a -> First a) -> (a -> Maybe a) -> a -> First a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> Maybe a
    forall a. a -> Maybe a
    Just)) f (Maybe a) -> f s
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom
    {-# INLINE pre #-}

    -- | This converts an 'IndexedFold' to an 'IndexPreservingGetter' that returns the first index
    -- and element, if they exist, as a 'Maybe'.
    --
    -- @
    -- 'ipre' :: 'IndexedGetter' i s a     -> 'IndexPreservingGetter' s ('Maybe' (i, a))
    -- 'ipre' :: 'IndexedFold' i s a       -> 'IndexPreservingGetter' s ('Maybe' (i, a))
    -- 'ipre' :: 'IndexedTraversal'' i s a -> 'IndexPreservingGetter' s ('Maybe' (i, a))
    -- 'ipre' :: 'IndexedLens'' i s a      -> 'IndexPreservingGetter' s ('Maybe' (i, a))
    -- @
    ipre :: IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
    ipre :: forall i a s.
    IndexedGetting i (First (i, a)) s a
    -> IndexPreservingGetter s (Maybe (i, a))
    ipre IndexedGetting i (First (i, a)) s a
    l = (s -> Maybe (i, a))
    -> (f (Maybe (i, a)) -> f s)
    -> p (Maybe (i, a)) (f (Maybe (i, a)))
    -> p s (f s)
    forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap (First (i, a) -> Maybe (i, a)
    forall a. First a -> Maybe a
    getFirst (First (i, a) -> Maybe (i, a))
    -> (s -> First (i, a)) -> s -> Maybe (i, a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Const (First (i, a)) s -> First (i, a)
    forall {k} a (b :: k). Const a b -> a
    getConst (Const (First (i, a)) s -> First (i, a))
    -> (s -> Const (First (i, a)) s) -> s -> First (i, a)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. IndexedGetting i (First (i, a)) s a
    l ((i -> a -> Const (First (i, a)) a)
    -> Indexed i a (Const (First (i, a)) a)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> Const (First (i, a)) a)
     -> Indexed i a (Const (First (i, a)) a))
    -> (i -> a -> Const (First (i, a)) a)
    -> Indexed i a (Const (First (i, a)) a)
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> First (i, a) -> Const (First (i, a)) a
    forall {k} a (b :: k). a -> Const a b
    Const (Maybe (i, a) -> First (i, a)
    forall a. Maybe a -> First a
    First ((i, a) -> Maybe (i, a)
    forall a. a -> Maybe a
    Just (i
    i, a
    a))))) f (Maybe (i, a)) -> f s
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom
    {-# INLINE ipre #-}

    ------------------------------------------------------------------------------
    -- Preview
    ------------------------------------------------------------------------------

    -- | Retrieve the first value targeted by a 'Fold' or 'Traversal' (or 'Just' the result
    -- from a 'Getter' or 'Lens'). See also 'firstOf' and '^?', which are similar with
    -- some subtle differences (explained below).
    --
    -- @
    -- 'Data.Maybe.listToMaybe' '.' 'toList' ≡ 'preview' 'folded'
    -- @
    --
    -- @
    -- 'preview' = 'view' '.' 'pre'
    -- @
    --
    --
    -- Unlike '^?', this function uses a
    -- 'Control.Monad.Reader.MonadReader' to read the value to be focused in on.
    -- This allows one to pass the value as the last argument by using the
    -- 'Control.Monad.Reader.MonadReader' instance for @(->) s@
    -- However, it may also be used as part of some deeply nested transformer stack.
    --
    -- 'preview' uses a monoidal value to obtain the result.
    -- This means that it generally has good performance, but can occasionally cause space leaks
    -- or even stack overflows on some data types.
    -- There is another function, 'firstOf', which avoids these issues at the cost of
    -- a slight constant performance cost and a little less flexibility.
    --
    -- It may be helpful to think of 'preview' as having one of the following
    -- more specialized types:
    --
    -- @
    -- 'preview' :: 'Getter' s a     -> s -> 'Maybe' a
    -- 'preview' :: 'Fold' s a       -> s -> 'Maybe' a
    -- 'preview' :: 'Lens'' s a      -> s -> 'Maybe' a
    -- 'preview' :: 'Iso'' s a       -> s -> 'Maybe' a
    -- 'preview' :: 'Traversal'' s a -> s -> 'Maybe' a
    -- @
    --
    --
    -- @
    -- 'preview' :: 'MonadReader' s m => 'Getter' s a     -> m ('Maybe' a)
    -- 'preview' :: 'MonadReader' s m => 'Fold' s a       -> m ('Maybe' a)
    -- 'preview' :: 'MonadReader' s m => 'Lens'' s a      -> m ('Maybe' a)
    -- 'preview' :: 'MonadReader' s m => 'Iso'' s a       -> m ('Maybe' a)
    -- 'preview' :: 'MonadReader' s m => 'Traversal'' s a -> m ('Maybe' a)
    --
    -- @
    preview :: MonadReader s m => Getting (First a) s a -> m (Maybe a)
    preview :: forall s (m :: * -> *) a.
    MonadReader s m =>
    Getting (First a) s a -> m (Maybe a)
    preview Getting (First a) s a
    l = (s -> Maybe a) -> m (Maybe a)
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks (First a -> Maybe a
    forall a. First a -> Maybe a
    getFirst (First a -> Maybe a) -> (s -> First a) -> s -> Maybe a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Getting (First a) s a -> (a -> First a) -> s -> First a
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (First a) s a
    l (Maybe a -> First a
    forall a. Maybe a -> First a
    First (Maybe a -> First a) -> (a -> Maybe a) -> a -> First a
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> Maybe a
    forall a. a -> Maybe a
    Just))
    {-# INLINE preview #-}

    -- | Retrieve the first index and value targeted by a 'Fold' or 'Traversal' (or 'Just' the result
    -- from a 'Getter' or 'Lens'). See also ('^@?').
    --
    -- @
    -- 'ipreview' = 'view' '.' 'ipre'
    -- @
    --
    -- This is usually applied in the 'Control.Monad.Reader.Reader'
    -- 'Control.Monad.Monad' @(->) s@.
    --
    -- @
    -- 'ipreview' :: 'IndexedGetter' i s a     -> s -> 'Maybe' (i, a)
    -- 'ipreview' :: 'IndexedFold' i s a       -> s -> 'Maybe' (i, a)
    -- 'ipreview' :: 'IndexedLens'' i s a      -> s -> 'Maybe' (i, a)
    -- 'ipreview' :: 'IndexedTraversal'' i s a -> s -> 'Maybe' (i, a)
    -- @
    --
    -- However, it may be useful to think of its full generality when working with
    -- a 'Control.Monad.Monad' transformer stack:
    --
    -- @
    -- 'ipreview' :: 'MonadReader' s m => 'IndexedGetter' s a     -> m ('Maybe' (i, a))
    -- 'ipreview' :: 'MonadReader' s m => 'IndexedFold' s a       -> m ('Maybe' (i, a))
    -- 'ipreview' :: 'MonadReader' s m => 'IndexedLens'' s a      -> m ('Maybe' (i, a))
    -- 'ipreview' :: 'MonadReader' s m => 'IndexedTraversal'' s a -> m ('Maybe' (i, a))
    -- @
    ipreview :: MonadReader s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
    ipreview :: forall s (m :: * -> *) i a.
    MonadReader s m =>
    IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
    ipreview IndexedGetting i (First (i, a)) s a
    l = (s -> Maybe (i, a)) -> m (Maybe (i, a))
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks (First (i, a) -> Maybe (i, a)
    forall a. First a -> Maybe a
    getFirst (First (i, a) -> Maybe (i, a))
    -> (s -> First (i, a)) -> s -> Maybe (i, a)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. IndexedGetting i (First (i, a)) s a
    -> (i -> a -> First (i, a)) -> s -> First (i, a)
    forall i m s a. IndexedGetting i m s a -> (i -> a -> m) -> s -> m
    ifoldMapOf IndexedGetting i (First (i, a)) s a
    l (\i
    i a
    a -> Maybe (i, a) -> First (i, a)
    forall a. Maybe a -> First a
    First ((i, a) -> Maybe (i, a)
    forall a. a -> Maybe a
    Just (i
    i, a
    a))))
    {-# INLINE ipreview #-}

    -- | Retrieve a function of the first value targeted by a 'Fold' or
    -- 'Traversal' (or 'Just' the result from a 'Getter' or 'Lens').
    --
    -- This is usually applied in the 'Control.Monad.Reader.Reader'
    -- 'Control.Monad.Monad' @(->) s@.

    -- @
    -- 'previews' = 'views' '.' 'pre'
    -- @
    --
    -- @
    -- 'previews' :: 'Getter' s a     -> (a -> r) -> s -> 'Maybe' r
    -- 'previews' :: 'Fold' s a       -> (a -> r) -> s -> 'Maybe' r
    -- 'previews' :: 'Lens'' s a      -> (a -> r) -> s -> 'Maybe' r
    -- 'previews' :: 'Iso'' s a       -> (a -> r) -> s -> 'Maybe' r
    -- 'previews' :: 'Traversal'' s a -> (a -> r) -> s -> 'Maybe' r
    -- @
    --
    -- However, it may be useful to think of its full generality when working with
    -- a 'Monad' transformer stack:
    --
    -- @
    -- 'previews' :: 'MonadReader' s m => 'Getter' s a     -> (a -> r) -> m ('Maybe' r)
    -- 'previews' :: 'MonadReader' s m => 'Fold' s a       -> (a -> r) -> m ('Maybe' r)
    -- 'previews' :: 'MonadReader' s m => 'Lens'' s a      -> (a -> r) -> m ('Maybe' r)
    -- 'previews' :: 'MonadReader' s m => 'Iso'' s a       -> (a -> r) -> m ('Maybe' r)
    -- 'previews' :: 'MonadReader' s m => 'Traversal'' s a -> (a -> r) -> m ('Maybe' r)
    -- @
    previews :: MonadReader s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
    previews :: forall s (m :: * -> *) r a.
    MonadReader s m =>
    Getting (First r) s a -> (a -> r) -> m (Maybe r)
    previews Getting (First r) s a
    l a -> r
    f = (s -> Maybe r) -> m (Maybe r)
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks (First r -> Maybe r
    forall a. First a -> Maybe a
    getFirst (First r -> Maybe r) -> (s -> First r) -> s -> Maybe r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting (First r) s a -> (a -> First r) -> s -> First r
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (First r) s a
    l (Maybe r -> First r
    forall a. Maybe a -> First a
    First (Maybe r -> First r) -> (a -> Maybe r) -> a -> First r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. r -> Maybe r
    forall a. a -> Maybe a
    Just (r -> Maybe r) -> (a -> r) -> a -> Maybe r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> r
    f))
    {-# INLINE previews #-}

    -- | Retrieve a function of the first index and value targeted by an 'IndexedFold' or
    -- 'IndexedTraversal' (or 'Just' the result from an 'IndexedGetter' or 'IndexedLens').
    -- See also ('^@?').
    --
    -- @
    -- 'ipreviews' = 'views' '.' 'ipre'
    -- @
    --
    -- This is usually applied in the 'Control.Monad.Reader.Reader'
    -- 'Control.Monad.Monad' @(->) s@.
    --
    -- @
    -- 'ipreviews' :: 'IndexedGetter' i s a     -> (i -> a -> r) -> s -> 'Maybe' r
    -- 'ipreviews' :: 'IndexedFold' i s a       -> (i -> a -> r) -> s -> 'Maybe' r
    -- 'ipreviews' :: 'IndexedLens'' i s a      -> (i -> a -> r) -> s -> 'Maybe' r
    -- 'ipreviews' :: 'IndexedTraversal'' i s a -> (i -> a -> r) -> s -> 'Maybe' r
    -- @
    --
    -- However, it may be useful to think of its full generality when working with
    -- a 'Control.Monad.Monad' transformer stack:
    --
    -- @
    -- 'ipreviews' :: 'MonadReader' s m => 'IndexedGetter' i s a     -> (i -> a -> r) -> m ('Maybe' r)
    -- 'ipreviews' :: 'MonadReader' s m => 'IndexedFold' i s a       -> (i -> a -> r) -> m ('Maybe' r)
    -- 'ipreviews' :: 'MonadReader' s m => 'IndexedLens'' i s a      -> (i -> a -> r) -> m ('Maybe' r)
    -- 'ipreviews' :: 'MonadReader' s m => 'IndexedTraversal'' i s a -> (i -> a -> r) -> m ('Maybe' r)
    -- @
    ipreviews :: MonadReader s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
    ipreviews :: forall s (m :: * -> *) i r a.
    MonadReader s m =>
    IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
    ipreviews IndexedGetting i (First r) s a
    l i -> a -> r
    f = (s -> Maybe r) -> m (Maybe r)
    forall r (m :: * -> *) a. MonadReader r m => (r -> a) -> m a
    asks (First r -> Maybe r
    forall a. First a -> Maybe a
    getFirst (First r -> Maybe r) -> (s -> First r) -> s -> Maybe r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IndexedGetting i (First r) s a
    -> (i -> a -> First r) -> s -> First r
    forall i m s a. IndexedGetting i m s a -> (i -> a -> m) -> s -> m
    ifoldMapOf IndexedGetting i (First r) s a
    l (\i
    i -> Maybe r -> First r
    forall a. Maybe a -> First a
    First (Maybe r -> First r) -> (a -> Maybe r) -> a -> First r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. r -> Maybe r
    forall a. a -> Maybe a
    Just (r -> Maybe r) -> (a -> r) -> a -> Maybe r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . i -> a -> r
    f i
    i))
    {-# INLINE ipreviews #-}

    ------------------------------------------------------------------------------
    -- Preuse
    ------------------------------------------------------------------------------

    -- | Retrieve the first value targeted by a 'Fold' or 'Traversal' (or 'Just' the result
    -- from a 'Getter' or 'Lens') into the current state.
    --
    -- @
    -- 'preuse' = 'use' '.' 'pre'
    -- @
    --
    -- @
    -- 'preuse' :: 'MonadState' s m => 'Getter' s a     -> m ('Maybe' a)
    -- 'preuse' :: 'MonadState' s m => 'Fold' s a       -> m ('Maybe' a)
    -- 'preuse' :: 'MonadState' s m => 'Lens'' s a      -> m ('Maybe' a)
    -- 'preuse' :: 'MonadState' s m => 'Iso'' s a       -> m ('Maybe' a)
    -- 'preuse' :: 'MonadState' s m => 'Traversal'' s a -> m ('Maybe' a)
    -- @
    preuse :: MonadState s m => Getting (First a) s a -> m (Maybe a)
    preuse :: forall s (m :: * -> *) a.
    MonadState s m =>
    Getting (First a) s a -> m (Maybe a)
    preuse Getting (First a) s a
    l = (s -> Maybe a) -> m (Maybe a)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets (Getting (First a) s a -> s -> Maybe a
    forall s (m :: * -> *) a.
    MonadReader s m =>
    Getting (First a) s a -> m (Maybe a)
    preview Getting (First a) s a
    l)
    {-# INLINE preuse #-}

    -- | Retrieve the first index and value targeted by an 'IndexedFold' or 'IndexedTraversal' (or 'Just' the index
    -- and result from an 'IndexedGetter' or 'IndexedLens') into the current state.
    --
    -- @
    -- 'ipreuse' = 'use' '.' 'ipre'
    -- @
    --
    -- @
    -- 'ipreuse' :: 'MonadState' s m => 'IndexedGetter' i s a     -> m ('Maybe' (i, a))
    -- 'ipreuse' :: 'MonadState' s m => 'IndexedFold' i s a       -> m ('Maybe' (i, a))
    -- 'ipreuse' :: 'MonadState' s m => 'IndexedLens'' i s a      -> m ('Maybe' (i, a))
    -- 'ipreuse' :: 'MonadState' s m => 'IndexedTraversal'' i s a -> m ('Maybe' (i, a))
    -- @
    ipreuse :: MonadState s m => IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
    ipreuse :: forall s (m :: * -> *) i a.
    MonadState s m =>
    IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
    ipreuse IndexedGetting i (First (i, a)) s a
    l = (s -> Maybe (i, a)) -> m (Maybe (i, a))
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets (IndexedGetting i (First (i, a)) s a -> s -> Maybe (i, a)
    forall s (m :: * -> *) i a.
    MonadReader s m =>
    IndexedGetting i (First (i, a)) s a -> m (Maybe (i, a))
    ipreview IndexedGetting i (First (i, a)) s a
    l)
    {-# INLINE ipreuse #-}

    -- | Retrieve a function of the first value targeted by a 'Fold' or
    -- 'Traversal' (or 'Just' the result from a 'Getter' or 'Lens') into the current state.
    --
    -- @
    -- 'preuses' = 'uses' '.' 'pre'
    -- @
    --
    -- @
    -- 'preuses' :: 'MonadState' s m => 'Getter' s a     -> (a -> r) -> m ('Maybe' r)
    -- 'preuses' :: 'MonadState' s m => 'Fold' s a       -> (a -> r) -> m ('Maybe' r)
    -- 'preuses' :: 'MonadState' s m => 'Lens'' s a      -> (a -> r) -> m ('Maybe' r)
    -- 'preuses' :: 'MonadState' s m => 'Iso'' s a       -> (a -> r) -> m ('Maybe' r)
    -- 'preuses' :: 'MonadState' s m => 'Traversal'' s a -> (a -> r) -> m ('Maybe' r)
    -- @
    preuses :: MonadState s m => Getting (First r) s a -> (a -> r) -> m (Maybe r)
    preuses :: forall s (m :: * -> *) r a.
    MonadState s m =>
    Getting (First r) s a -> (a -> r) -> m (Maybe r)
    preuses Getting (First r) s a
    l a -> r
    f = (s -> Maybe r) -> m (Maybe r)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets (Getting (First r) s a -> (a -> r) -> s -> Maybe r
    forall s (m :: * -> *) r a.
    MonadReader s m =>
    Getting (First r) s a -> (a -> r) -> m (Maybe r)
    previews Getting (First r) s a
    l a -> r
    f)
    {-# INLINE preuses #-}

    -- | Retrieve a function of the first index and value targeted by an 'IndexedFold' or
    -- 'IndexedTraversal' (or a function of 'Just' the index and result from an 'IndexedGetter'
    -- or 'IndexedLens') into the current state.
    --
    -- @
    -- 'ipreuses' = 'uses' '.' 'ipre'
    -- @
    --
    -- @
    -- 'ipreuses' :: 'MonadState' s m => 'IndexedGetter' i s a     -> (i -> a -> r) -> m ('Maybe' r)
    -- 'ipreuses' :: 'MonadState' s m => 'IndexedFold' i s a       -> (i -> a -> r) -> m ('Maybe' r)
    -- 'ipreuses' :: 'MonadState' s m => 'IndexedLens'' i s a      -> (i -> a -> r) -> m ('Maybe' r)
    -- 'ipreuses' :: 'MonadState' s m => 'IndexedTraversal'' i s a -> (i -> a -> r) -> m ('Maybe' r)
    -- @
    ipreuses :: MonadState s m => IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
    ipreuses :: forall s (m :: * -> *) i r a.
    MonadState s m =>
    IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
    ipreuses IndexedGetting i (First r) s a
    l i -> a -> r
    f = (s -> Maybe r) -> m (Maybe r)
    forall s (m :: * -> *) a. MonadState s m => (s -> a) -> m a
    gets (IndexedGetting i (First r) s a -> (i -> a -> r) -> s -> Maybe r
    forall s (m :: * -> *) i r a.
    MonadReader s m =>
    IndexedGetting i (First r) s a -> (i -> a -> r) -> m (Maybe r)
    ipreviews IndexedGetting i (First r) s a
    l i -> a -> r
    f)
    {-# INLINE ipreuses #-}

    ------------------------------------------------------------------------------
    -- Profunctors
    ------------------------------------------------------------------------------

    -- | This allows you to 'Control.Traversable.traverse' the elements of a pretty much any 'LensLike' construction in the opposite order.
    --
    -- This will preserve indexes on 'Indexed' types and will give you the elements of a (finite) 'Fold' or 'Traversal' in the opposite order.
    --
    -- This has no practical impact on a 'Getter', 'Setter', 'Lens' or 'Iso'.
    --
    -- /NB:/ To write back through an 'Iso', you want to use 'Control.Lens.Isomorphic.from'.
    -- Similarly, to write back through an 'Prism', you want to use 'Control.Lens.Review.re'.
    backwards :: (Profunctor p, Profunctor q) => Optical p q (Backwards f) s t a b -> Optical p q f s t a b
    backwards :: forall (p :: * -> * -> *) (q :: * -> * -> *) (f :: * -> *) s t a b.
    (Profunctor p, Profunctor q) =>
    Optical p q (Backwards f) s t a b -> Optical p q f s t a b
    backwards Optical p q (Backwards f) s t a b
    l p a (f b)
    f = Backwards f t -> f t
    forall {k} (f :: k -> *) (a :: k). Backwards f a -> f a
    forwards (Backwards f t -> f t) -> q s (Backwards f t) -> q s (f t)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> q a b -> q a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Optical p q (Backwards f) s t a b
    l (f b -> Backwards f b
    forall {k} (f :: k -> *) (a :: k). f a -> Backwards f a
    Backwards (f b -> Backwards f b) -> p a (f b) -> p a (Backwards f b)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> p a b -> p a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. p a (f b)
    f)
    {-# INLINE backwards #-}

    ------------------------------------------------------------------------------
    -- Indexed Folds
    ------------------------------------------------------------------------------

    -- | Fold an 'IndexedFold' or 'IndexedTraversal' by mapping indices and values to an arbitrary 'Monoid' with access
    -- to the @i@.
    --
    -- When you don't need access to the index then 'foldMapOf' is more flexible in what it accepts.
    --
    -- @
    -- 'foldMapOf' l ≡ 'ifoldMapOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifoldMapOf' ::             'IndexedGetter' i s a     -> (i -> a -> m) -> s -> m
    -- 'ifoldMapOf' :: 'Monoid' m => 'IndexedFold' i s a       -> (i -> a -> m) -> s -> m
    -- 'ifoldMapOf' ::             'IndexedLens'' i s a      -> (i -> a -> m) -> s -> m
    -- 'ifoldMapOf' :: 'Monoid' m => 'IndexedTraversal'' i s a -> (i -> a -> m) -> s -> m
    -- @
    --
    ifoldMapOf :: IndexedGetting i m s a -> (i -> a -> m) -> s -> m
    ifoldMapOf :: forall i m s a. IndexedGetting i m s a -> (i -> a -> m) -> s -> m
    ifoldMapOf = IndexedGetting i m s a -> (i -> a -> m) -> s -> m
    forall a b. Coercible a b => a -> b
    coerce
    {-# INLINE ifoldMapOf #-}

    -- | Right-associative fold of parts of a structure that are viewed through an 'IndexedFold' or 'IndexedTraversal' with
    -- access to the @i@.
    --
    -- When you don't need access to the index then 'foldrOf' is more flexible in what it accepts.
    --
    -- @
    -- 'foldrOf' l ≡ 'ifoldrOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifoldrOf' :: 'IndexedGetter' i s a     -> (i -> a -> r -> r) -> r -> s -> r
    -- 'ifoldrOf' :: 'IndexedFold' i s a       -> (i -> a -> r -> r) -> r -> s -> r
    -- 'ifoldrOf' :: 'IndexedLens'' i s a      -> (i -> a -> r -> r) -> r -> s -> r
    -- 'ifoldrOf' :: 'IndexedTraversal'' i s a -> (i -> a -> r -> r) -> r -> s -> r
    -- @
    ifoldrOf :: IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf :: forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo r) s a
    l i -> a -> r -> r
    f r
    z = (Endo r -> r -> r) -> r -> Endo r -> r
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Endo r -> r -> r
    forall a. Endo a -> a -> a
    appEndo r
    z (Endo r -> r) -> (s -> Endo r) -> s -> r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Const (Endo r) s -> Endo r
    forall {k} a (b :: k). Const a b -> a
    getConst (Const (Endo r) s -> Endo r)
    -> (s -> Const (Endo r) s) -> s -> Endo r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. IndexedGetting i (Endo r) s a
    l (Endo r -> Const (Endo r) a
    forall {k} a (b :: k). a -> Const a b
    Const (Endo r -> Const (Endo r) a)
    -> Indexed i a (Endo r) -> Indexed i a (Const (Endo r) a)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Indexed i a b -> Indexed i a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo ((r -> r) -> Endo r)
    -> Indexed i a (r -> r) -> Indexed i a (Endo r)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Indexed i a b -> Indexed i a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (i -> a -> r -> r) -> Indexed i a (r -> r)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed i -> a -> r -> r
    f)
    {-# INLINE ifoldrOf #-}

    -- | Left-associative fold of the parts of a structure that are viewed through an 'IndexedFold' or 'IndexedTraversal' with
    -- access to the @i@.
    --
    -- When you don't need access to the index then 'foldlOf' is more flexible in what it accepts.
    --
    -- @
    -- 'foldlOf' l ≡ 'ifoldlOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifoldlOf' :: 'IndexedGetter' i s a     -> (i -> r -> a -> r) -> r -> s -> r
    -- 'ifoldlOf' :: 'IndexedFold' i s a       -> (i -> r -> a -> r) -> r -> s -> r
    -- 'ifoldlOf' :: 'IndexedLens'' i s a      -> (i -> r -> a -> r) -> r -> s -> r
    -- 'ifoldlOf' :: 'IndexedTraversal'' i s a -> (i -> r -> a -> r) -> r -> s -> r
    -- @
    ifoldlOf :: IndexedGetting i (Dual (Endo r)) s a -> (i -> r -> a -> r) -> r -> s -> r
    ifoldlOf :: forall i r s a.
    IndexedGetting i (Dual (Endo r)) s a
    -> (i -> r -> a -> r) -> r -> s -> r
    ifoldlOf IndexedGetting i (Dual (Endo r)) s a
    l i -> r -> a -> r
    f r
    z = ((Endo r -> r -> r) -> r -> Endo r -> r
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Endo r -> r -> r
    forall a. Endo a -> a -> a
    appEndo r
    z (Endo r -> r) -> (Dual (Endo r) -> Endo r) -> Dual (Endo r) -> r
    forall a b c (q :: * -> * -> *).
    Coercible b a =>
    (b -> c) -> q a b -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible b a) =>
    p b c -> q a b -> p a c
    .# Dual (Endo r) -> Endo r
    forall a. Dual a -> a
    getDual) (Dual (Endo r) -> r) -> (s -> Dual (Endo r)) -> s -> r
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) b c a.
    Profunctor p =>
    (b -> c) -> p a b -> p a c
    `rmap` IndexedGetting i (Dual (Endo r)) s a
    -> (i -> a -> Dual (Endo r)) -> s -> Dual (Endo r)
    forall i m s a. IndexedGetting i m s a -> (i -> a -> m) -> s -> m
    ifoldMapOf IndexedGetting i (Dual (Endo r)) s a
    l (\i
    i -> Endo r -> Dual (Endo r)
    forall a. a -> Dual a
    Dual (Endo r -> Dual (Endo r)) -> (a -> Endo r) -> a -> Dual (Endo r)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (r -> r) -> Endo r
    forall a. (a -> a) -> Endo a
    Endo ((r -> r) -> Endo r) -> (a -> r -> r) -> a -> Endo r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (r -> a -> r) -> a -> r -> r
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (i -> r -> a -> r
    f i
    i))
    {-# INLINE ifoldlOf #-}

    -- | Return whether or not any element viewed through an 'IndexedFold' or 'IndexedTraversal'
    -- satisfy a predicate, with access to the @i@.
    --
    -- When you don't need access to the index then 'anyOf' is more flexible in what it accepts.
    --
    -- @
    -- 'anyOf' l ≡ 'ianyOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ianyOf' :: 'IndexedGetter' i s a     -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'ianyOf' :: 'IndexedFold' i s a       -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'ianyOf' :: 'IndexedLens'' i s a      -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'ianyOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- @
    ianyOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
    ianyOf :: forall i s a.
    IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
    ianyOf = IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
    forall a b. Coercible a b => a -> b
    coerce
    {-# INLINE ianyOf #-}

    -- | Return whether or not all elements viewed through an 'IndexedFold' or 'IndexedTraversal'
    -- satisfy a predicate, with access to the @i@.
    --
    -- When you don't need access to the index then 'allOf' is more flexible in what it accepts.
    --
    -- @
    -- 'allOf' l ≡ 'iallOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'iallOf' :: 'IndexedGetter' i s a     -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'iallOf' :: 'IndexedFold' i s a       -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'iallOf' :: 'IndexedLens'' i s a      -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'iallOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- @
    iallOf :: IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
    iallOf :: forall i s a.
    IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
    iallOf = IndexedGetting i All s a -> (i -> a -> Bool) -> s -> Bool
    forall a b. Coercible a b => a -> b
    coerce
    {-# INLINE iallOf #-}

    -- | Return whether or not none of the elements viewed through an 'IndexedFold' or 'IndexedTraversal'
    -- satisfy a predicate, with access to the @i@.
    --
    -- When you don't need access to the index then 'noneOf' is more flexible in what it accepts.
    --
    -- @
    -- 'noneOf' l ≡ 'inoneOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'inoneOf' :: 'IndexedGetter' i s a     -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'inoneOf' :: 'IndexedFold' i s a       -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'inoneOf' :: 'IndexedLens'' i s a      -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- 'inoneOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Bool'
    -- @
    inoneOf :: IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
    inoneOf :: forall i s a.
    IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
    inoneOf IndexedGetting i Any s a
    l i -> a -> Bool
    f = Bool -> Bool
    not (Bool -> Bool) -> (s -> Bool) -> s -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
    forall i s a.
    IndexedGetting i Any s a -> (i -> a -> Bool) -> s -> Bool
    ianyOf IndexedGetting i Any s a
    l i -> a -> Bool
    f
    {-# INLINE inoneOf #-}

    -- | Traverse the targets of an 'IndexedFold' or 'IndexedTraversal' with access to the @i@, discarding the results.
    --
    -- When you don't need access to the index then 'traverseOf_' is more flexible in what it accepts.
    --
    -- @
    -- 'traverseOf_' l ≡ 'Control.Lens.Traversal.itraverseOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'itraverseOf_' :: 'Functor' f     => 'IndexedGetter' i s a     -> (i -> a -> f r) -> s -> f ()
    -- 'itraverseOf_' :: 'Applicative' f => 'IndexedFold' i s a       -> (i -> a -> f r) -> s -> f ()
    -- 'itraverseOf_' :: 'Functor' f     => 'IndexedLens'' i s a      -> (i -> a -> f r) -> s -> f ()
    -- 'itraverseOf_' :: 'Applicative' f => 'IndexedTraversal'' i s a -> (i -> a -> f r) -> s -> f ()
    -- @
    itraverseOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> (i -> a -> f r) -> s -> f ()
    itraverseOf_ :: forall (f :: * -> *) i r s a.
    Functor f =>
    IndexedGetting i (Traversed r f) s a
    -> (i -> a -> f r) -> s -> f ()
    itraverseOf_ IndexedGetting i (Traversed r f) s a
    l i -> a -> f r
    f = f r -> f ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (f r -> f ()) -> (s -> f r) -> s -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Traversed r f -> f r
    forall a (f :: * -> *). Traversed a f -> f a
    getTraversed (Traversed r f -> f r) -> (s -> Traversed r f) -> s -> f r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Const (Traversed r f) s -> Traversed r f
    forall {k} a (b :: k). Const a b -> a
    getConst (Const (Traversed r f) s -> Traversed r f)
    -> (s -> Const (Traversed r f) s) -> s -> Traversed r f
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. IndexedGetting i (Traversed r f) s a
    l (Traversed r f -> Const (Traversed r f) a
    forall {k} a (b :: k). a -> Const a b
    Const (Traversed r f -> Const (Traversed r f) a)
    -> Indexed i a (Traversed r f)
    -> Indexed i a (Const (Traversed r f) a)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Indexed i a b -> Indexed i a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. f r -> Traversed r f
    forall a (f :: * -> *). f a -> Traversed a f
    Traversed (f r -> Traversed r f)
    -> Indexed i a (f r) -> Indexed i a (Traversed r f)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Indexed i a b -> Indexed i a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (i -> a -> f r) -> Indexed i a (f r)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed i -> a -> f r
    f)
    {-# INLINE itraverseOf_ #-}

    -- | Traverse the targets of an 'IndexedFold' or 'IndexedTraversal' with access to the index, discarding the results
    -- (with the arguments flipped).
    --
    -- @
    -- 'iforOf_' ≡ 'flip' '.' 'itraverseOf_'
    -- @
    --
    -- When you don't need access to the index then 'forOf_' is more flexible in what it accepts.
    --
    -- @
    -- 'forOf_' l a ≡ 'iforOf_' l a '.' 'const'
    -- @
    --
    -- @
    -- 'iforOf_' :: 'Functor' f     => 'IndexedGetter' i s a     -> s -> (i -> a -> f r) -> f ()
    -- 'iforOf_' :: 'Applicative' f => 'IndexedFold' i s a       -> s -> (i -> a -> f r) -> f ()
    -- 'iforOf_' :: 'Functor' f     => 'IndexedLens'' i s a      -> s -> (i -> a -> f r) -> f ()
    -- 'iforOf_' :: 'Applicative' f => 'IndexedTraversal'' i s a -> s -> (i -> a -> f r) -> f ()
    -- @
    iforOf_ :: Functor f => IndexedGetting i (Traversed r f) s a -> s -> (i -> a -> f r) -> f ()
    iforOf_ :: forall (f :: * -> *) i r s a.
    Functor f =>
    IndexedGetting i (Traversed r f) s a
    -> s -> (i -> a -> f r) -> f ()
    iforOf_ = ((i -> a -> f r) -> s -> f ()) -> s -> (i -> a -> f r) -> f ()
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (((i -> a -> f r) -> s -> f ()) -> s -> (i -> a -> f r) -> f ())
    -> (IndexedGetting i (Traversed r f) s a
        -> (i -> a -> f r) -> s -> f ())
    -> IndexedGetting i (Traversed r f) s a
    -> s
    -> (i -> a -> f r)
    -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IndexedGetting i (Traversed r f) s a
    -> (i -> a -> f r) -> s -> f ()
    forall (f :: * -> *) i r s a.
    Functor f =>
    IndexedGetting i (Traversed r f) s a
    -> (i -> a -> f r) -> s -> f ()
    itraverseOf_
    {-# INLINE iforOf_ #-}

    -- | Run monadic actions for each target of an 'IndexedFold' or 'IndexedTraversal' with access to the index,
    -- discarding the results.
    --
    -- When you don't need access to the index then 'mapMOf_' is more flexible in what it accepts.
    --
    -- @
    -- 'mapMOf_' l ≡ 'Control.Lens.Setter.imapMOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'imapMOf_' :: 'Monad' m => 'IndexedGetter' i s a     -> (i -> a -> m r) -> s -> m ()
    -- 'imapMOf_' :: 'Monad' m => 'IndexedFold' i s a       -> (i -> a -> m r) -> s -> m ()
    -- 'imapMOf_' :: 'Monad' m => 'IndexedLens'' i s a      -> (i -> a -> m r) -> s -> m ()
    -- 'imapMOf_' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> a -> m r) -> s -> m ()
    -- @
    imapMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> (i -> a -> m r) -> s -> m ()
    imapMOf_ :: forall (m :: * -> *) i r s a.
    Monad m =>
    IndexedGetting i (Sequenced r m) s a
    -> (i -> a -> m r) -> s -> m ()
    imapMOf_ IndexedGetting i (Sequenced r m) s a
    l i -> a -> m r
    f = (r -> ()) -> m r -> m ()
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM r -> ()
    forall a. a -> ()
    skip (m r -> m ()) -> (s -> m r) -> s -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Sequenced r m -> m r
    forall a (m :: * -> *). Sequenced a m -> m a
    getSequenced (Sequenced r m -> m r) -> (s -> Sequenced r m) -> s -> m r
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. Const (Sequenced r m) s -> Sequenced r m
    forall {k} a (b :: k). Const a b -> a
    getConst (Const (Sequenced r m) s -> Sequenced r m)
    -> (s -> Const (Sequenced r m) s) -> s -> Sequenced r m
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. IndexedGetting i (Sequenced r m) s a
    l (Sequenced r m -> Const (Sequenced r m) a
    forall {k} a (b :: k). a -> Const a b
    Const (Sequenced r m -> Const (Sequenced r m) a)
    -> Indexed i a (Sequenced r m)
    -> Indexed i a (Const (Sequenced r m) a)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Indexed i a b -> Indexed i a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. m r -> Sequenced r m
    forall a (m :: * -> *). m a -> Sequenced a m
    Sequenced (m r -> Sequenced r m)
    -> Indexed i a (m r) -> Indexed i a (Sequenced r m)
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Indexed i a b -> Indexed i a c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. (i -> a -> m r) -> Indexed i a (m r)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed i -> a -> m r
    f)
    {-# INLINE imapMOf_ #-}

    -- | Run monadic actions for each target of an 'IndexedFold' or 'IndexedTraversal' with access to the index,
    -- discarding the results (with the arguments flipped).
    --
    -- @
    -- 'iforMOf_' ≡ 'flip' '.' 'imapMOf_'
    -- @
    --
    -- When you don't need access to the index then 'forMOf_' is more flexible in what it accepts.
    --
    -- @
    -- 'forMOf_' l a ≡ 'Control.Lens.Traversal.iforMOf' l a '.' 'const'
    -- @
    --
    -- @
    -- 'iforMOf_' :: 'Monad' m => 'IndexedGetter' i s a     -> s -> (i -> a -> m r) -> m ()
    -- 'iforMOf_' :: 'Monad' m => 'IndexedFold' i s a       -> s -> (i -> a -> m r) -> m ()
    -- 'iforMOf_' :: 'Monad' m => 'IndexedLens'' i s a      -> s -> (i -> a -> m r) -> m ()
    -- 'iforMOf_' :: 'Monad' m => 'IndexedTraversal'' i s a -> s -> (i -> a -> m r) -> m ()
    -- @
    iforMOf_ :: Monad m => IndexedGetting i (Sequenced r m) s a -> s -> (i -> a -> m r) -> m ()
    iforMOf_ :: forall (m :: * -> *) i r s a.
    Monad m =>
    IndexedGetting i (Sequenced r m) s a
    -> s -> (i -> a -> m r) -> m ()
    iforMOf_ = ((i -> a -> m r) -> s -> m ()) -> s -> (i -> a -> m r) -> m ()
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (((i -> a -> m r) -> s -> m ()) -> s -> (i -> a -> m r) -> m ())
    -> (IndexedGetting i (Sequenced r m) s a
        -> (i -> a -> m r) -> s -> m ())
    -> IndexedGetting i (Sequenced r m) s a
    -> s
    -> (i -> a -> m r)
    -> m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IndexedGetting i (Sequenced r m) s a
    -> (i -> a -> m r) -> s -> m ()
    forall (m :: * -> *) i r s a.
    Monad m =>
    IndexedGetting i (Sequenced r m) s a
    -> (i -> a -> m r) -> s -> m ()
    imapMOf_
    {-# INLINE iforMOf_ #-}

    -- | Concatenate the results of a function of the elements of an 'IndexedFold' or 'IndexedTraversal'
    -- with access to the index.
    --
    -- When you don't need access to the index then 'concatMapOf'  is more flexible in what it accepts.
    --
    -- @
    -- 'concatMapOf' l ≡ 'iconcatMapOf' l '.' 'const'
    -- 'iconcatMapOf' ≡ 'ifoldMapOf'
    -- @
    --
    -- @
    -- 'iconcatMapOf' :: 'IndexedGetter' i s a     -> (i -> a -> [r]) -> s -> [r]
    -- 'iconcatMapOf' :: 'IndexedFold' i s a       -> (i -> a -> [r]) -> s -> [r]
    -- 'iconcatMapOf' :: 'IndexedLens'' i s a      -> (i -> a -> [r]) -> s -> [r]
    -- 'iconcatMapOf' :: 'IndexedTraversal'' i s a -> (i -> a -> [r]) -> s -> [r]
    -- @
    iconcatMapOf :: IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
    iconcatMapOf :: forall i r s a.
    IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
    iconcatMapOf = IndexedGetting i [r] s a -> (i -> a -> [r]) -> s -> [r]
    forall i m s a. IndexedGetting i m s a -> (i -> a -> m) -> s -> m
    ifoldMapOf
    {-# INLINE iconcatMapOf #-}

    -- | The 'ifindOf' function takes an 'IndexedFold' or 'IndexedTraversal', a predicate that is also
    -- supplied the index, a structure and returns the left-most element of the structure
    -- matching the predicate, or 'Nothing' if there is no such element.
    --
    -- When you don't need access to the index then 'findOf' is more flexible in what it accepts.
    --
    -- @
    -- 'findOf' l ≡ 'ifindOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifindOf' :: 'IndexedGetter' i s a     -> (i -> a -> 'Bool') -> s -> 'Maybe' a
    -- 'ifindOf' :: 'IndexedFold' i s a       -> (i -> a -> 'Bool') -> s -> 'Maybe' a
    -- 'ifindOf' :: 'IndexedLens'' i s a      -> (i -> a -> 'Bool') -> s -> 'Maybe' a
    -- 'ifindOf' :: 'IndexedTraversal'' i s a -> (i -> a -> 'Bool') -> s -> 'Maybe' a
    -- @
    ifindOf :: IndexedGetting i (Endo (Maybe a)) s a -> (i -> a -> Bool) -> s -> Maybe a
    ifindOf :: forall i a s.
    IndexedGetting i (Endo (Maybe a)) s a
    -> (i -> a -> Bool) -> s -> Maybe a
    ifindOf IndexedGetting i (Endo (Maybe a)) s a
    l i -> a -> Bool
    f = IndexedGetting i (Endo (Maybe a)) s a
    -> (i -> a -> Maybe a -> Maybe a) -> Maybe a -> s -> Maybe a
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo (Maybe a)) s a
    l (\i
    i a
    a Maybe a
    y -> if i -> a -> Bool
    f i
    i a
    a then a -> Maybe a
    forall a. a -> Maybe a
    Just a
    a else Maybe a
    y) Maybe a
    forall a. Maybe a
    Nothing
    {-# INLINE ifindOf #-}

    -- | The 'ifindMOf' function takes an 'IndexedFold' or 'IndexedTraversal', a monadic predicate that is also
    -- supplied the index, a structure and returns in the monad the left-most element of the structure
    -- matching the predicate, or 'Nothing' if there is no such element.
    --
    -- When you don't need access to the index then 'findMOf' is more flexible in what it accepts.
    --
    -- @
    -- 'findMOf' l ≡ 'ifindMOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifindMOf' :: 'Monad' m => 'IndexedGetter' i s a     -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'ifindMOf' :: 'Monad' m => 'IndexedFold' i s a       -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'ifindMOf' :: 'Monad' m => 'IndexedLens'' i s a      -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
    -- 'ifindMOf' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> a -> m 'Bool') -> s -> m ('Maybe' a)
    -- @
    ifindMOf :: Monad m => IndexedGetting i (Endo (m (Maybe a))) s a -> (i -> a -> m Bool) -> s -> m (Maybe a)
    ifindMOf :: forall (m :: * -> *) i a s.
    Monad m =>
    IndexedGetting i (Endo (m (Maybe a))) s a
    -> (i -> a -> m Bool) -> s -> m (Maybe a)
    ifindMOf IndexedGetting i (Endo (m (Maybe a))) s a
    l i -> a -> m Bool
    f = IndexedGetting i (Endo (m (Maybe a))) s a
    -> (i -> a -> m (Maybe a) -> m (Maybe a))
    -> m (Maybe a)
    -> s
    -> m (Maybe a)
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo (m (Maybe a))) s a
    l (\i
    i a
    a m (Maybe a)
    y -> i -> a -> m Bool
    f i
    i a
    a m Bool -> (Bool -> m (Maybe a)) -> m (Maybe a)
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \Bool
    r -> if Bool
    r then Maybe a -> m (Maybe a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> Maybe a
    forall a. a -> Maybe a
    Just a
    a) else m (Maybe a)
    y) (m (Maybe a) -> s -> m (Maybe a))
    -> m (Maybe a) -> s -> m (Maybe a)
    forall a b. (a -> b) -> a -> b
    $ Maybe a -> m (Maybe a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Maybe a
    forall a. Maybe a
    Nothing
    {-# INLINE ifindMOf #-}

    -- | /Strictly/ fold right over the elements of a structure with an index.
    --
    -- When you don't need access to the index then 'foldrOf'' is more flexible in what it accepts.
    --
    -- @
    -- 'foldrOf'' l ≡ 'ifoldrOf'' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifoldrOf'' :: 'IndexedGetter' i s a     -> (i -> a -> r -> r) -> r -> s -> r
    -- 'ifoldrOf'' :: 'IndexedFold' i s a       -> (i -> a -> r -> r) -> r -> s -> r
    -- 'ifoldrOf'' :: 'IndexedLens'' i s a      -> (i -> a -> r -> r) -> r -> s -> r
    -- 'ifoldrOf'' :: 'IndexedTraversal'' i s a -> (i -> a -> r -> r) -> r -> s -> r
    -- @
    ifoldrOf' :: IndexedGetting i (Dual (Endo (r -> r))) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf' :: forall i r s a.
    IndexedGetting i (Dual (Endo (r -> r))) s a
    -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf' IndexedGetting i (Dual (Endo (r -> r))) s a
    l i -> a -> r -> r
    f r
    z0 s
    xs = IndexedGetting i (Dual (Endo (r -> r))) s a
    -> (i -> (r -> r) -> a -> r -> r) -> (r -> r) -> s -> r -> r
    forall i r s a.
    IndexedGetting i (Dual (Endo r)) s a
    -> (i -> r -> a -> r) -> r -> s -> r
    ifoldlOf IndexedGetting i (Dual (Endo (r -> r))) s a
    l i -> (r -> r) -> a -> r -> r
    forall {b}. i -> (r -> b) -> a -> r -> b
    f' r -> r
    forall a. a -> a
    id s
    xs r
    z0
      where f' :: i -> (r -> b) -> a -> r -> b
    f' i
    i r -> b
    k a
    x r
    z = r -> b
    k (r -> b) -> r -> b
    forall a b. (a -> b) -> a -> b
    $! i -> a -> r -> r
    f i
    i a
    x r
    z
    {-# INLINE ifoldrOf' #-}

    -- | Fold over the elements of a structure with an index, associating to the left, but /strictly/.
    --
    -- When you don't need access to the index then 'foldlOf'' is more flexible in what it accepts.
    --
    -- @
    -- 'foldlOf'' l ≡ 'ifoldlOf'' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifoldlOf'' :: 'IndexedGetter' i s a       -> (i -> r -> a -> r) -> r -> s -> r
    -- 'ifoldlOf'' :: 'IndexedFold' i s a         -> (i -> r -> a -> r) -> r -> s -> r
    -- 'ifoldlOf'' :: 'IndexedLens'' i s a        -> (i -> r -> a -> r) -> r -> s -> r
    -- 'ifoldlOf'' :: 'IndexedTraversal'' i s a   -> (i -> r -> a -> r) -> r -> s -> r
    -- @
    ifoldlOf' :: IndexedGetting i (Endo (r -> r)) s a -> (i -> r -> a -> r) -> r -> s -> r
    ifoldlOf' :: forall i r s a.
    IndexedGetting i (Endo (r -> r)) s a
    -> (i -> r -> a -> r) -> r -> s -> r
    ifoldlOf' IndexedGetting i (Endo (r -> r)) s a
    l i -> r -> a -> r
    f r
    z0 s
    xs = IndexedGetting i (Endo (r -> r)) s a
    -> (i -> a -> (r -> r) -> r -> r) -> (r -> r) -> s -> r -> r
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo (r -> r)) s a
    l i -> a -> (r -> r) -> r -> r
    forall {b}. i -> a -> (r -> b) -> r -> b
    f' r -> r
    forall a. a -> a
    id s
    xs r
    z0
      where f' :: i -> a -> (r -> b) -> r -> b
    f' i
    i a
    x r -> b
    k r
    z = r -> b
    k (r -> b) -> r -> b
    forall a b. (a -> b) -> a -> b
    $! i -> r -> a -> r
    f i
    i r
    z a
    x
    {-# INLINE ifoldlOf' #-}

    -- | Monadic fold right over the elements of a structure with an index.
    --
    -- When you don't need access to the index then 'foldrMOf' is more flexible in what it accepts.
    --
    -- @
    -- 'foldrMOf' l ≡ 'ifoldrMOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifoldrMOf' :: 'Monad' m => 'IndexedGetter' i s a     -> (i -> a -> r -> m r) -> r -> s -> m r
    -- 'ifoldrMOf' :: 'Monad' m => 'IndexedFold' i s a       -> (i -> a -> r -> m r) -> r -> s -> m r
    -- 'ifoldrMOf' :: 'Monad' m => 'IndexedLens'' i s a      -> (i -> a -> r -> m r) -> r -> s -> m r
    -- 'ifoldrMOf' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> a -> r -> m r) -> r -> s -> m r
    -- @
    ifoldrMOf :: Monad m => IndexedGetting i (Dual (Endo (r -> m r))) s a -> (i -> a -> r -> m r) -> r -> s -> m r
    ifoldrMOf :: forall (m :: * -> *) i r s a.
    Monad m =>
    IndexedGetting i (Dual (Endo (r -> m r))) s a
    -> (i -> a -> r -> m r) -> r -> s -> m r
    ifoldrMOf IndexedGetting i (Dual (Endo (r -> m r))) s a
    l i -> a -> r -> m r
    f r
    z0 s
    xs = IndexedGetting i (Dual (Endo (r -> m r))) s a
    -> (i -> (r -> m r) -> a -> r -> m r)
    -> (r -> m r)
    -> s
    -> r
    -> m r
    forall i r s a.
    IndexedGetting i (Dual (Endo r)) s a
    -> (i -> r -> a -> r) -> r -> s -> r
    ifoldlOf IndexedGetting i (Dual (Endo (r -> m r))) s a
    l i -> (r -> m r) -> a -> r -> m r
    forall {b}. i -> (r -> m b) -> a -> r -> m b
    f' r -> m r
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return s
    xs r
    z0
      where f' :: i -> (r -> m b) -> a -> r -> m b
    f' i
    i r -> m b
    k a
    x r
    z = i -> a -> r -> m r
    f i
    i a
    x r
    z m r -> (r -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= r -> m b
    k
    {-# INLINE ifoldrMOf #-}

    -- | Monadic fold over the elements of a structure with an index, associating to the left.
    --
    -- When you don't need access to the index then 'foldlMOf' is more flexible in what it accepts.
    --
    -- @
    -- 'foldlMOf' l ≡ 'ifoldlMOf' l '.' 'const'
    -- @
    --
    -- @
    -- 'ifoldlMOf' :: 'Monad' m => 'IndexedGetter' i s a     -> (i -> r -> a -> m r) -> r -> s -> m r
    -- 'ifoldlMOf' :: 'Monad' m => 'IndexedFold' i s a       -> (i -> r -> a -> m r) -> r -> s -> m r
    -- 'ifoldlMOf' :: 'Monad' m => 'IndexedLens'' i s a      -> (i -> r -> a -> m r) -> r -> s -> m r
    -- 'ifoldlMOf' :: 'Monad' m => 'IndexedTraversal'' i s a -> (i -> r -> a -> m r) -> r -> s -> m r
    -- @
    ifoldlMOf :: Monad m => IndexedGetting i (Endo (r -> m r)) s a -> (i -> r -> a -> m r) -> r -> s -> m r
    ifoldlMOf :: forall (m :: * -> *) i r s a.
    Monad m =>
    IndexedGetting i (Endo (r -> m r)) s a
    -> (i -> r -> a -> m r) -> r -> s -> m r
    ifoldlMOf IndexedGetting i (Endo (r -> m r)) s a
    l i -> r -> a -> m r
    f r
    z0 s
    xs = IndexedGetting i (Endo (r -> m r)) s a
    -> (i -> a -> (r -> m r) -> r -> m r)
    -> (r -> m r)
    -> s
    -> r
    -> m r
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo (r -> m r)) s a
    l i -> a -> (r -> m r) -> r -> m r
    forall {b}. i -> a -> (r -> m b) -> r -> m b
    f' r -> m r
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return s
    xs r
    z0
      where f' :: i -> a -> (r -> m b) -> r -> m b
    f' i
    i a
    x r -> m b
    k r
    z = i -> r -> a -> m r
    f i
    i r
    z a
    x m r -> (r -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= r -> m b
    k
    {-# INLINE ifoldlMOf #-}

    -- | Extract the key-value pairs from a structure.
    --
    -- When you don't need access to the indices in the result, then 'toListOf' is more flexible in what it accepts.
    --
    -- @
    -- 'toListOf' l ≡ 'map' 'snd' '.' 'itoListOf' l
    -- @
    --
    -- @
    -- 'itoListOf' :: 'IndexedGetter' i s a     -> s -> [(i,a)]
    -- 'itoListOf' :: 'IndexedFold' i s a       -> s -> [(i,a)]
    -- 'itoListOf' :: 'IndexedLens'' i s a      -> s -> [(i,a)]
    -- 'itoListOf' :: 'IndexedTraversal'' i s a -> s -> [(i,a)]
    -- @
    itoListOf :: IndexedGetting i (Endo [(i,a)]) s a -> s -> [(i,a)]
    itoListOf :: forall i a s. IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
    itoListOf IndexedGetting i (Endo [(i, a)]) s a
    l = IndexedGetting i (Endo [(i, a)]) s a
    -> (i -> a -> [(i, a)] -> [(i, a)]) -> [(i, a)] -> s -> [(i, a)]
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo [(i, a)]) s a
    l (\i
    i a
    a -> ((i
    i,a
    a)(i, a) -> [(i, a)] -> [(i, a)]
    forall a. a -> [a] -> [a]
    :)) []
    {-# INLINE itoListOf #-}

    -- | An infix version of 'itoListOf'.

    -- @
    -- ('^@..') :: s -> 'IndexedGetter' i s a     -> [(i,a)]
    -- ('^@..') :: s -> 'IndexedFold' i s a       -> [(i,a)]
    -- ('^@..') :: s -> 'IndexedLens'' i s a      -> [(i,a)]
    -- ('^@..') :: s -> 'IndexedTraversal'' i s a -> [(i,a)]
    -- @
    (^@..) :: s -> IndexedGetting i (Endo [(i,a)]) s a -> [(i,a)]
    s
    s ^@.. :: forall s i a. s -> IndexedGetting i (Endo [(i, a)]) s a -> [(i, a)]
    ^@.. IndexedGetting i (Endo [(i, a)]) s a
    l = IndexedGetting i (Endo [(i, a)]) s a
    -> (i -> a -> [(i, a)] -> [(i, a)]) -> [(i, a)] -> s -> [(i, a)]
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo [(i, a)]) s a
    l (\i
    i a
    a -> ((i
    i,a
    a)(i, a) -> [(i, a)] -> [(i, a)]
    forall a. a -> [a] -> [a]
    :)) [] s
    s
    {-# INLINE (^@..) #-}

    -- | Perform a safe 'head' (with index) of an 'IndexedFold' or 'IndexedTraversal' or retrieve 'Just' the index and result
    -- from an 'IndexedGetter' or 'IndexedLens'.
    --
    -- When using a 'IndexedTraversal' as a partial 'IndexedLens', or an 'IndexedFold' as a partial 'IndexedGetter' this can be a convenient
    -- way to extract the optional value.
    --
    -- @
    -- ('^@?') :: s -> 'IndexedGetter' i s a     -> 'Maybe' (i, a)
    -- ('^@?') :: s -> 'IndexedFold' i s a       -> 'Maybe' (i, a)
    -- ('^@?') :: s -> 'IndexedLens'' i s a      -> 'Maybe' (i, a)
    -- ('^@?') :: s -> 'IndexedTraversal'' i s a -> 'Maybe' (i, a)
    -- @
    (^@?) :: s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
    s
    s ^@? :: forall s i a.
    s -> IndexedGetting i (Endo (Maybe (i, a))) s a -> Maybe (i, a)
    ^@? IndexedGetting i (Endo (Maybe (i, a))) s a
    l = IndexedGetting i (Endo (Maybe (i, a))) s a
    -> (i -> a -> Maybe (i, a) -> Maybe (i, a))
    -> Maybe (i, a)
    -> s
    -> Maybe (i, a)
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo (Maybe (i, a))) s a
    l (\i
    i a
    x Maybe (i, a)
    _ -> (i, a) -> Maybe (i, a)
    forall a. a -> Maybe a
    Just (i
    i,a
    x)) Maybe (i, a)
    forall a. Maybe a
    Nothing s
    s
    {-# INLINE (^@?) #-}

    -- | Perform an *UNSAFE* 'head' (with index) of an 'IndexedFold' or 'IndexedTraversal' assuming that it is there.
    --
    -- @
    -- ('^@?!') :: s -> 'IndexedGetter' i s a     -> (i, a)
    -- ('^@?!') :: s -> 'IndexedFold' i s a       -> (i, a)
    -- ('^@?!') :: s -> 'IndexedLens'' i s a      -> (i, a)
    -- ('^@?!') :: s -> 'IndexedTraversal'' i s a -> (i, a)
    -- @
    (^@?!) :: HasCallStack => s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
    s
    s ^@?! :: forall s i a.
    HasCallStack =>
    s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
    ^@?! IndexedGetting i (Endo (i, a)) s a
    l = IndexedGetting i (Endo (i, a)) s a
    -> (i -> a -> (i, a) -> (i, a)) -> (i, a) -> s -> (i, a)
    forall i r s a.
    IndexedGetting i (Endo r) s a -> (i -> a -> r -> r) -> r -> s -> r
    ifoldrOf IndexedGetting i (Endo (i, a)) s a
    l (\i
    i a
    x (i, a)
    _ -> (i
    i,a
    x)) (String -> (i, a)
    forall a. HasCallStack => String -> a
    error String
    "(^@?!): empty Fold") s
    s
    {-# INLINE (^@?!) #-}

    -- | Retrieve the index of the first value targeted by a 'IndexedFold' or 'IndexedTraversal' which is equal to a given value.
    --
    -- @
    -- 'Data.List.elemIndex' ≡ 'elemIndexOf' 'folded'
    -- @
    --
    -- @
    -- 'elemIndexOf' :: 'Eq' a => 'IndexedFold' i s a       -> a -> s -> 'Maybe' i
    -- 'elemIndexOf' :: 'Eq' a => 'IndexedTraversal'' i s a -> a -> s -> 'Maybe' i
    -- @
    elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
    elemIndexOf :: forall a i s.
    Eq a =>
    IndexedGetting i (First i) s a -> a -> s -> Maybe i
    elemIndexOf IndexedGetting i (First i) s a
    l a
    a = IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
    forall i s a.
    IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
    findIndexOf IndexedGetting i (First i) s a
    l (a
    a a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    ==)
    {-# INLINE elemIndexOf #-}

    -- | Retrieve the indices of the values targeted by a 'IndexedFold' or 'IndexedTraversal' which are equal to a given value.
    --
    -- @
    -- 'Data.List.elemIndices' ≡ 'elemIndicesOf' 'folded'
    -- @
    --
    -- @
    -- 'elemIndicesOf' :: 'Eq' a => 'IndexedFold' i s a       -> a -> s -> [i]
    -- 'elemIndicesOf' :: 'Eq' a => 'IndexedTraversal'' i s a -> a -> s -> [i]
    -- @
    elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
    elemIndicesOf :: forall a i s.
    Eq a =>
    IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
    elemIndicesOf IndexedGetting i (Endo [i]) s a
    l a
    a = IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
    forall i s a.
    IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
    findIndicesOf IndexedGetting i (Endo [i]) s a
    l (a
    a a -> a -> Bool
    forall a. Eq a => a -> a -> Bool
    ==)
    {-# INLINE elemIndicesOf #-}

    -- | Retrieve the index of the first value targeted by a 'IndexedFold' or 'IndexedTraversal' which satisfies a predicate.
    --
    -- @
    -- 'Data.List.findIndex' ≡ 'findIndexOf' 'folded'
    -- @
    --
    -- @
    -- 'findIndexOf' :: 'IndexedFold' i s a       -> (a -> 'Bool') -> s -> 'Maybe' i
    -- 'findIndexOf' :: 'IndexedTraversal'' i s a -> (a -> 'Bool') -> s -> 'Maybe' i
    -- @
    findIndexOf :: IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
    findIndexOf :: forall i s a.
    IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
    findIndexOf IndexedGetting i (First i) s a
    l a -> Bool
    p = Getting (First i) s i -> s -> Maybe i
    forall s (m :: * -> *) a.
    MonadReader s m =>
    Getting (First a) s a -> m (Maybe a)
    preview (IndexedGetting i (First i) s a
    l IndexedGetting i (First i) s a
    -> ((i -> Const (First i) i) -> Indexed i a (Const (First i) a))
    -> Getting (First i) s i
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Bool) -> Optic' (Indexed i) (Const (First i)) a a
    forall (p :: * -> * -> *) (f :: * -> *) a.
    (Choice p, Applicative f) =>
    (a -> Bool) -> Optic' p f a a
    filtered a -> Bool
    p Optic' (Indexed i) (Const (First i)) a a
    -> ((i -> Const (First i) i) -> Indexed i a (Const (First i) a))
    -> (i -> Const (First i) i)
    -> Indexed i a (Const (First i) a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (i -> Const (First i) i) -> Indexed i a (Const (First i) a)
    forall i (p :: * -> * -> *) (f :: * -> *) s.
    (Indexable i p, Contravariant f, Functor f) =>
    p i (f i) -> Indexed i s (f s)
    asIndex)
    {-# INLINE findIndexOf #-}

    -- | Retrieve the indices of the values targeted by a 'IndexedFold' or 'IndexedTraversal' which satisfy a predicate.
    --
    -- @
    -- 'Data.List.findIndices' ≡ 'findIndicesOf' 'folded'
    -- @
    --
    -- @
    -- 'findIndicesOf' :: 'IndexedFold' i s a       -> (a -> 'Bool') -> s -> [i]
    -- 'findIndicesOf' :: 'IndexedTraversal'' i s a -> (a -> 'Bool') -> s -> [i]
    -- @
    findIndicesOf :: IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
    findIndicesOf :: forall i s a.
    IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
    findIndicesOf IndexedGetting i (Endo [i]) s a
    l a -> Bool
    p = Getting (Endo [i]) s i -> s -> [i]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf (IndexedGetting i (Endo [i]) s a
    l IndexedGetting i (Endo [i]) s a
    -> ((i -> Const (Endo [i]) i) -> Indexed i a (Const (Endo [i]) a))
    -> Getting (Endo [i]) s i
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Bool) -> Optic' (Indexed i) (Const (Endo [i])) a a
    forall (p :: * -> * -> *) (f :: * -> *) a.
    (Choice p, Applicative f) =>
    (a -> Bool) -> Optic' p f a a
    filtered a -> Bool
    p Optic' (Indexed i) (Const (Endo [i])) a a
    -> ((i -> Const (Endo [i]) i) -> Indexed i a (Const (Endo [i]) a))
    -> (i -> Const (Endo [i]) i)
    -> Indexed i a (Const (Endo [i]) a)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (i -> Const (Endo [i]) i) -> Indexed i a (Const (Endo [i]) a)
    forall i (p :: * -> * -> *) (f :: * -> *) s.
    (Indexable i p, Contravariant f, Functor f) =>
    p i (f i) -> Indexed i s (f s)
    asIndex)
    {-# INLINE findIndicesOf #-}

    -------------------------------------------------------------------------------
    -- Converting to Folds
    -------------------------------------------------------------------------------

    -- | Filter an 'IndexedFold' or 'IndexedGetter', obtaining an 'IndexedFold'.
    --
    -- >>> [0,0,0,5,5,5]^..traversed.ifiltered (\i a -> i <= a)
    -- [0,5,5,5]
    --
    -- Compose with 'ifiltered' to filter another 'IndexedLens', 'IndexedIso', 'IndexedGetter', 'IndexedFold' (or 'IndexedTraversal') with
    -- access to both the value and the index.
    --
    -- Note: As with 'filtered', this is /not/ a legal 'IndexedTraversal', unless you are very careful not to invalidate the predicate on the target!
    ifiltered :: (Indexable i p, Applicative f) => (i -> a -> Bool) -> Optical' p (Indexed i) f a a
    ifiltered :: forall i (p :: * -> * -> *) (f :: * -> *) a.
    (Indexable i p, Applicative f) =>
    (i -> a -> Bool) -> Optical' p (Indexed i) f a a
    ifiltered i -> a -> Bool
    p p a (f a)
    f = (i -> a -> f a) -> Indexed i a (f a)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> f a) -> Indexed i a (f a))
    -> (i -> a -> f a) -> Indexed i a (f a)
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> if i -> a -> Bool
    p i
    i a
    a then p a (f a) -> i -> a -> f a
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f a)
    f i
    i a
    a else a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    a
    {-# INLINE ifiltered #-}

    -- | Obtain an 'IndexedFold' by taking elements from another
    -- 'IndexedFold', 'IndexedLens', 'IndexedGetter' or 'IndexedTraversal' while a predicate holds.
    --
    -- @
    -- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedFold' i s a          -> 'IndexedFold' i s a
    -- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedTraversal'' i s a    -> 'IndexedFold' i s a
    -- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedLens'' i s a         -> 'IndexedFold' i s a
    -- 'itakingWhile' :: (i -> a -> 'Bool') -> 'IndexedGetter' i s a        -> 'IndexedFold' i s a
    -- @
    --
    -- Note: Applying 'itakingWhile' to an 'IndexedLens' or 'IndexedTraversal' will still allow you to use it as a
    -- pseudo-'IndexedTraversal', but if you change the value of any target to one where the predicate returns
    -- 'False', then you will break the 'Traversal' laws and 'Traversal' fusion will no longer be sound.
    itakingWhile :: (Indexable i p, Profunctor q, Contravariant f, Applicative f)
             => (i -> a -> Bool)
             -> Optical' (Indexed i) q (Const (Endo (f s))) s a
             -> Optical' p q f s a
    itakingWhile :: forall i (p :: * -> * -> *) (q :: * -> * -> *) (f :: * -> *) a s.
    (Indexable i p, Profunctor q, Contravariant f, Applicative f) =>
    (i -> a -> Bool)
    -> Optical' (Indexed i) q (Const (Endo (f s))) s a
    -> Optical' p q f s a
    itakingWhile i -> a -> Bool
    p Optical' (Indexed i) q (Const (Endo (f s))) s a
    l p a (f a)
    f = ((Endo (f s) -> f s -> f s) -> f s -> Endo (f s) -> f s
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip Endo (f s) -> f s -> f s
    forall a. Endo a -> a -> a
    appEndo f s
    forall (f :: * -> *) a. (Contravariant f, Applicative f) => f a
    noEffect (Endo (f s) -> f s)
    -> (Const (Endo (f s)) s -> Endo (f s))
    -> Const (Endo (f s)) s
    -> f s
    forall a b c (q :: * -> * -> *).
    Coercible b a =>
    (b -> c) -> q a b -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible b a) =>
    p b c -> q a b -> p a c
    .# Const (Endo (f s)) s -> Endo (f s)
    forall {k} a (b :: k). Const a b -> a
    getConst) (Const (Endo (f s)) s -> f s)
    -> q s (Const (Endo (f s)) s) -> q s (f s)
    forall b c a. (b -> c) -> q a b -> q a c
    forall (p :: * -> * -> *) b c a.
    Profunctor p =>
    (b -> c) -> p a b -> p a c
    `rmap` Optical' (Indexed i) q (Const (Endo (f s))) s a
    l Indexed i a (Const (Endo (f s)) a)
    forall {b} {b}. Indexed i a (Const (Endo (f b)) b)
    g where
      g :: Indexed i a (Const (Endo (f b)) b)
    g = (i -> a -> Const (Endo (f b)) b)
    -> Indexed i a (Const (Endo (f b)) b)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> Const (Endo (f b)) b)
     -> Indexed i a (Const (Endo (f b)) b))
    -> (i -> a -> Const (Endo (f b)) b)
    -> Indexed i a (Const (Endo (f b)) b)
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> Endo (f b) -> Const (Endo (f b)) b
    forall {k} a (b :: k). a -> Const a b
    Const (Endo (f b) -> Const (Endo (f b)) b)
    -> ((f b -> f b) -> Endo (f b))
    -> (f b -> f b)
    -> Const (Endo (f b)) b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (f b -> f b) -> Endo (f b)
    forall a. (a -> a) -> Endo a
    Endo ((f b -> f b) -> Const (Endo (f b)) b)
    -> (f b -> f b) -> Const (Endo (f b)) b
    forall a b. (a -> b) -> a -> b
    $ if i -> a -> Bool
    p i
    i a
    a then (p a (f a) -> i -> a -> f a
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f a)
    f i
    i a
    a f a -> f b -> f b
    forall a b. f a -> f b -> f b
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *>) else f b -> f b -> f b
    forall a b. a -> b -> a
    const f b
    forall (f :: * -> *) a. (Contravariant f, Applicative f) => f a
    noEffect
    {-# INLINE itakingWhile #-}

    -- | Obtain an 'IndexedFold' by dropping elements from another 'IndexedFold', 'IndexedLens', 'IndexedGetter' or 'IndexedTraversal' while a predicate holds.
    --
    -- @
    -- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedFold' i s a          -> 'IndexedFold' i s a
    -- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedTraversal'' i s a    -> 'IndexedFold' i s a -- see notes
    -- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedLens'' i s a         -> 'IndexedFold' i s a -- see notes
    -- 'idroppingWhile' :: (i -> a -> 'Bool') -> 'IndexedGetter' i s a        -> 'IndexedFold' i s a
    -- @
    --
    -- Note: As with `droppingWhile` applying 'idroppingWhile' to an 'IndexedLens' or 'IndexedTraversal' will still
    -- allow you to use it as a pseudo-'IndexedTraversal', but if you change the value of the first target to one
    -- where the predicate returns 'True', then you will break the 'Traversal' laws and 'Traversal' fusion will
    -- no longer be sound.
    idroppingWhile :: (Indexable i p, Profunctor q, Applicative f)
                  => (i -> a -> Bool)
                  -> Optical (Indexed i) q (Compose (State Bool) f) s t a a
                  -> Optical p q f s t a a
    idroppingWhile :: forall i (p :: * -> * -> *) (q :: * -> * -> *) (f :: * -> *) a s t.
    (Indexable i p, Profunctor q, Applicative f) =>
    (i -> a -> Bool)
    -> Optical (Indexed i) q (Compose (State Bool) f) s t a a
    -> Optical p q f s t a a
    idroppingWhile i -> a -> Bool
    p Optical (Indexed i) q (Compose (State Bool) f) s t a a
    l p a (f a)
    f = ((State Bool (f t) -> Bool -> f t)
    -> Bool -> State Bool (f t) -> f t
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip State Bool (f t) -> Bool -> f t
    forall s a. State s a -> s -> a
    evalState Bool
    True (State Bool (f t) -> f t)
    -> (Compose (State Bool) f t -> State Bool (f t))
    -> Compose (State Bool) f t
    -> f t
    forall a b c (q :: * -> * -> *).
    Coercible b a =>
    (b -> c) -> q a b -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible b a) =>
    p b c -> q a b -> p a c
    .# Compose (State Bool) f t -> State Bool (f t)
    forall {k1} {k2} (f :: k1 -> *) (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    getCompose) (Compose (State Bool) f t -> f t)
    -> q s (Compose (State Bool) f t) -> q s (f t)
    forall b c a. (b -> c) -> q a b -> q a c
    forall (p :: * -> * -> *) b c a.
    Profunctor p =>
    (b -> c) -> p a b -> p a c
    `rmap` Optical (Indexed i) q (Compose (State Bool) f) s t a a
    l Indexed i a (Compose (State Bool) f a)
    g where
      g :: Indexed i a (Compose (State Bool) f a)
    g = (i -> a -> Compose (State Bool) f a)
    -> Indexed i a (Compose (State Bool) f a)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> Compose (State Bool) f a)
     -> Indexed i a (Compose (State Bool) f a))
    -> (i -> a -> Compose (State Bool) f a)
    -> Indexed i a (Compose (State Bool) f a)
    forall a b. (a -> b) -> a -> b
    $ \ i
    i a
    a -> State Bool (f a) -> Compose (State Bool) f a
    forall {k} {k1} (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Compose (State Bool (f a) -> Compose (State Bool) f a)
    -> State Bool (f a) -> Compose (State Bool) f a
    forall a b. (a -> b) -> a -> b
    $ (Bool -> (f a, Bool)) -> State Bool (f a)
    forall a. (Bool -> (a, Bool)) -> State Bool a
    forall s (m :: * -> *) a. MonadState s m => (s -> (a, s)) -> m a
    state ((Bool -> (f a, Bool)) -> State Bool (f a))
    -> (Bool -> (f a, Bool)) -> State Bool (f a)
    forall a b. (a -> b) -> a -> b
    $ \Bool
    b -> let
          b' :: Bool
    b' = Bool
    b Bool -> Bool -> Bool
    && i -> a -> Bool
    p i
    i a
    a
        in (if Bool
    b' then a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    a else p a (f a) -> i -> a -> f a
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f a)
    f i
    i a
    a, Bool
    b')
    {-# INLINE idroppingWhile #-}

    ------------------------------------------------------------------------------
    -- Misc.
    ------------------------------------------------------------------------------

    skip :: a -> ()
    skip :: forall a. a -> ()
    skip a
    _ = ()
    {-# INLINE skip #-}

    ------------------------------------------------------------------------------
    -- Folds with Reified Monoid
    ------------------------------------------------------------------------------

    -- | Fold a value using a specified 'Fold' and 'Monoid' operations.
    -- This is like 'foldBy' where the 'Foldable' instance can be
    -- manually specified.
    --
    -- @
    -- 'foldByOf' 'folded' ≡ 'foldBy'
    -- @
    --
    -- @
    -- 'foldByOf' :: 'Getter' s a     -> (a -> a -> a) -> a -> s -> a
    -- 'foldByOf' :: 'Fold' s a       -> (a -> a -> a) -> a -> s -> a
    -- 'foldByOf' :: 'Lens'' s a      -> (a -> a -> a) -> a -> s -> a
    -- 'foldByOf' :: 'Traversal'' s a -> (a -> a -> a) -> a -> s -> a
    -- 'foldByOf' :: 'Iso'' s a       -> (a -> a -> a) -> a -> s -> a
    -- @
    --
    -- >>> foldByOf both (++) [] ("hello","world")
    -- "helloworld"
    foldByOf :: Fold s a -> (a -> a -> a) -> a -> s -> a
    foldByOf :: forall s a. Fold s a -> (a -> a -> a) -> a -> s -> a
    foldByOf Fold s a
    l a -> a -> a
    f a
    z = (a -> a -> a)
    -> a
    -> (forall s.
        Reifies s (ReifiedMonoid a) =>
        s -> ReflectedMonoid a s)
    -> s
    -> a
    forall a t.
    (a -> a -> a)
    -> a
    -> (forall s.
        Reifies s (ReifiedMonoid a) =>
        t -> ReflectedMonoid a s)
    -> t
    -> a
    reifyMonoid a -> a -> a
    f a
    z (Getting (ReflectedMonoid a s) s a
    -> (a -> ReflectedMonoid a s) -> s -> ReflectedMonoid a s
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (ReflectedMonoid a s) s a
    Fold s a
    l a -> ReflectedMonoid a s
    forall {k} a (s :: k). a -> ReflectedMonoid a s
    ReflectedMonoid)

    -- | Fold a value using a specified 'Fold' and 'Monoid' operations.
    -- This is like 'foldMapBy' where the 'Foldable' instance can be
    -- manually specified.
    --
    -- @
    -- 'foldMapByOf' 'folded' ≡ 'foldMapBy'
    -- @
    --
    -- @
    -- 'foldMapByOf' :: 'Getter' s a     -> (r -> r -> r) -> r -> (a -> r) -> s -> r
    -- 'foldMapByOf' :: 'Fold' s a       -> (r -> r -> r) -> r -> (a -> r) -> s -> r
    -- 'foldMapByOf' :: 'Traversal'' s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
    -- 'foldMapByOf' :: 'Lens'' s a      -> (r -> r -> r) -> r -> (a -> r) -> s -> r
    -- 'foldMapByOf' :: 'Iso'' s a       -> (r -> r -> r) -> r -> (a -> r) -> s -> r
    -- @
    --
    -- >>> foldMapByOf both (+) 0 length ("hello","world")
    -- 10
    foldMapByOf :: Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
    foldMapByOf :: forall s a r. Fold s a -> (r -> r -> r) -> r -> (a -> r) -> s -> r
    foldMapByOf Fold s a
    l r -> r -> r
    f r
    z a -> r
    g = (r -> r -> r)
    -> r
    -> (forall s.
        Reifies s (ReifiedMonoid r) =>
        s -> ReflectedMonoid r s)
    -> s
    -> r
    forall a t.
    (a -> a -> a)
    -> a
    -> (forall s.
        Reifies s (ReifiedMonoid a) =>
        t -> ReflectedMonoid a s)
    -> t
    -> a
    reifyMonoid r -> r -> r
    f r
    z (Getting (ReflectedMonoid r s) s a
    -> (a -> ReflectedMonoid r s) -> s -> ReflectedMonoid r s
    forall r s a. Getting r s a -> (a -> r) -> s -> r
    foldMapOf Getting (ReflectedMonoid r s) s a
    Fold s a
    l (r -> ReflectedMonoid r s
    forall {k} a (s :: k). a -> ReflectedMonoid a s
    ReflectedMonoid (r -> ReflectedMonoid r s) -> (a -> r) -> a -> ReflectedMonoid r s
    forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> (a -> b) -> a -> c
    forall (p :: * -> * -> *) a b c (q :: * -> * -> *).
    (Profunctor p, Coercible c b) =>
    q b c -> p a b -> p a c
    #. a -> r
    g))