    {-# LANGUAGE CPP #-}
    {-# LANGUAGE Rank2Types #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE TypeFamilies #-}
    ------------------------------------------------------------------------------
    -- |
    -- Module      :  Control.Lens.Reified
    -- Copyright   :  (C) 2012-16 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  provisional
    -- Portability :  Rank2Types
    --
    ------------------------------------------------------------------------------
    module Control.Lens.Reified where

    import Control.Applicative
    import Control.Arrow
    import qualified Control.Category as Cat
    import Control.Comonad
    import Control.Lens.Fold
    import Control.Lens.Getter
    import Control.Lens.Internal.Indexed
    import Control.Lens.Traversal (ignored)
    import Control.Lens.Type
    import Control.Monad
    import Control.Monad.Reader.Class
    import Data.Distributive
    import Data.Foldable
    import Data.Functor.Compose
    import Data.Functor.Contravariant
    import Data.Functor.Bind
    import Data.Functor.Extend
    import Data.Functor.Identity
    import Data.Functor.Plus
    import Data.Profunctor.Closed
    import Data.Profunctor
    import Data.Profunctor.Rep
    import Data.Profunctor.Sieve
    #if !(MIN_VERSION_base(4,11,0))
    import Data.Semigroup
    #endif

    -- $setup
    -- >>> import Control.Lens

    ------------------------------------------------------------------------------
    -- Lens
    ------------------------------------------------------------------------------

    -- | Reify a 'Lens' so it can be stored safely in a container.
    newtype ReifiedLens s t a b = Lens { ReifiedLens s t a b
    -> forall (f :: * -> *). Functor f => (a -> f b) -> s -> f t
    runLens :: Lens s t a b }

    -- | @
    -- type 'ReifiedLens'' = 'Simple' 'ReifiedLens'
    -- @
    type ReifiedLens' s a = ReifiedLens s s a a

    ------------------------------------------------------------------------------
    -- IndexedLens
    ------------------------------------------------------------------------------

    -- | Reify an 'IndexedLens' so it can be stored safely in a container.
    newtype ReifiedIndexedLens i s t a b = IndexedLens { ReifiedIndexedLens i s t a b
    -> forall (f :: * -> *) (p :: * -> * -> *).
       (Indexable i p, Functor f) =>
       p a (f b) -> s -> f t
    runIndexedLens :: IndexedLens i s t a b }

    -- | @
    -- type 'ReifiedIndexedLens'' i = 'Simple' ('ReifiedIndexedLens' i)
    -- @
    type ReifiedIndexedLens' i s a = ReifiedIndexedLens i s s a a

    ------------------------------------------------------------------------------
    -- IndexedTraversal
    ------------------------------------------------------------------------------

    -- | Reify an 'IndexedTraversal' so it can be stored safely in a container.
    newtype ReifiedIndexedTraversal i s t a b = IndexedTraversal { ReifiedIndexedTraversal i s t a b
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Applicative f) =>
       p a (f b) -> s -> f t
    runIndexedTraversal :: IndexedTraversal i s t a b }

    -- | @
    -- type 'ReifiedIndexedTraversal'' i = 'Simple' ('ReifiedIndexedTraversal' i)
    -- @
    type ReifiedIndexedTraversal' i s a = ReifiedIndexedTraversal i s s a a

    ------------------------------------------------------------------------------
    -- Traversal
    ------------------------------------------------------------------------------

    -- | A form of 'Traversal' that can be stored monomorphically in a container.
    newtype ReifiedTraversal s t a b = Traversal { ReifiedTraversal s t a b
    -> forall (f :: * -> *). Applicative f => (a -> f b) -> s -> f t
    runTraversal :: Traversal s t a b }

    -- | @
    -- type 'ReifiedTraversal'' = 'Simple' 'ReifiedTraversal'
    -- @
    type ReifiedTraversal' s a = ReifiedTraversal s s a a

    ------------------------------------------------------------------------------
    -- Getter
    ------------------------------------------------------------------------------

    -- | Reify a 'Getter' so it can be stored safely in a container.
    --
    -- This can also be useful when combining getters in novel ways, as
    -- 'ReifiedGetter' is isomorphic to '(->)' and provides similar instances.
    --
    -- >>> ("hello","world","!!!")^.runGetter ((,) <$> Getter _2 <*> Getter (_1.to length))
    -- ("world",5)
    newtype ReifiedGetter s a = Getter { ReifiedGetter s a
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (a -> f a) -> s -> f s
    runGetter :: Getter s a }

    instance Distributive (ReifiedGetter s) where
      distribute :: f (ReifiedGetter s a) -> ReifiedGetter s (f a)
    distribute as :: f (ReifiedGetter s a)
    as = Getter s (f a) -> ReifiedGetter s (f a)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s (f a) -> ReifiedGetter s (f a))
    -> Getter s (f a) -> ReifiedGetter s (f a)
    forall a b. (a -> b) -> a -> b
    $ (s -> f a) -> Optic' (->) f s (f a)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> f a) -> Optic' (->) f s (f a))
    -> (s -> f a) -> Optic' (->) f s (f a)
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> (ReifiedGetter s a -> a) -> f (ReifiedGetter s a) -> f a
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap (\(Getter l :: Getter s a
    l) -> Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    l s
    s) f (ReifiedGetter s a)
    as

    instance Functor (ReifiedGetter s) where
      fmap :: (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b
    fmap f :: a -> b
    f l :: ReifiedGetter s a
    l = Getter s b -> ReifiedGetter s b
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (ReifiedGetter s a
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (a -> f a) -> s -> f s
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter s a
    l((a -> f a) -> s -> f s)
    -> ((b -> f b) -> a -> f a) -> (b -> f b) -> s -> f s
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(a -> b) -> (b -> f b) -> a -> f a
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f)
      {-# INLINE fmap #-}

    instance Semigroup s => Extend (ReifiedGetter s) where
      duplicated :: ReifiedGetter s a -> ReifiedGetter s (ReifiedGetter s a)
    duplicated (Getter l :: Getter s a
    l) = Getter s (ReifiedGetter s a) -> ReifiedGetter s (ReifiedGetter s a)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s (ReifiedGetter s a)
     -> ReifiedGetter s (ReifiedGetter s a))
    -> Getter s (ReifiedGetter s a)
    -> ReifiedGetter s (ReifiedGetter s a)
    forall a b. (a -> b) -> a -> b
    $ (s -> ReifiedGetter s a) -> Optic' (->) f s (ReifiedGetter s a)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> ReifiedGetter s a) -> Optic' (->) f s (ReifiedGetter s a))
    -> (s -> ReifiedGetter s a) -> Optic' (->) f s (ReifiedGetter s a)
    forall a b. (a -> b) -> a -> b
    $ \m :: s
    m -> Getter s a -> ReifiedGetter s a
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s a -> ReifiedGetter s a)
    -> Getter s a -> ReifiedGetter s a
    forall a b. (a -> b) -> a -> b
    $ (s -> a) -> Optic' (->) f s a
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> a) -> Optic' (->) f s a) -> (s -> a) -> Optic' (->) f s a
    forall a b. (a -> b) -> a -> b
    $ \n :: s
    n -> Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    l (s
    m s -> s -> s
    forall a. Semigroup a => a -> a -> a
    <> s
    n)
      {-# INLINE duplicated #-}

    instance Monoid s => Comonad (ReifiedGetter s) where
      extract :: ReifiedGetter s a -> a
    extract (Getter l :: Getter s a
    l) = Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    l s
    forall a. Monoid a => a
    mempty
      {-# INLINE extract #-}
      duplicate :: ReifiedGetter s a -> ReifiedGetter s (ReifiedGetter s a)
    duplicate (Getter l :: Getter s a
    l) = Getter s (ReifiedGetter s a) -> ReifiedGetter s (ReifiedGetter s a)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s (ReifiedGetter s a)
     -> ReifiedGetter s (ReifiedGetter s a))
    -> Getter s (ReifiedGetter s a)
    -> ReifiedGetter s (ReifiedGetter s a)
    forall a b. (a -> b) -> a -> b
    $ (s -> ReifiedGetter s a) -> Optic' (->) f s (ReifiedGetter s a)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> ReifiedGetter s a) -> Optic' (->) f s (ReifiedGetter s a))
    -> (s -> ReifiedGetter s a) -> Optic' (->) f s (ReifiedGetter s a)
    forall a b. (a -> b) -> a -> b
    $ \m :: s
    m -> Getter s a -> ReifiedGetter s a
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s a -> ReifiedGetter s a)
    -> Getter s a -> ReifiedGetter s a
    forall a b. (a -> b) -> a -> b
    $ (s -> a) -> Optic' (->) f s a
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> a) -> Optic' (->) f s a) -> (s -> a) -> Optic' (->) f s a
    forall a b. (a -> b) -> a -> b
    $ \n :: s
    n -> Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    l (s -> s -> s
    forall a. Monoid a => a -> a -> a
    mappend s
    m s
    n)
      {-# INLINE duplicate #-}

    instance Monoid s => ComonadApply (ReifiedGetter s) where
      Getter mf :: Getter s (a -> b)
    mf <@> :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b
    <@> Getter ma :: Getter s a
    ma = Getter s b -> ReifiedGetter s b
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s b -> ReifiedGetter s b)
    -> Getter s b -> ReifiedGetter s b
    forall a b. (a -> b) -> a -> b
    $ (s -> b) -> Optic' (->) f s b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> b) -> Optic' (->) f s b) -> (s -> b) -> Optic' (->) f s b
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (a -> b) s (a -> b) -> s -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting (a -> b) s (a -> b)
    Getter s (a -> b)
    mf s
    s (Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    ma s
    s)
      {-# INLINE (<@>) #-}
      m :: ReifiedGetter s a
    m <@ :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a
    <@ _ = ReifiedGetter s a
    m
      {-# INLINE (<@) #-}
      _ @> :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b
    @> m :: ReifiedGetter s b
    m = ReifiedGetter s b
    m
      {-# INLINE (@>) #-}

    instance Apply (ReifiedGetter s) where
      Getter mf :: Getter s (a -> b)
    mf <.> :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b
    <.> Getter ma :: Getter s a
    ma = Getter s b -> ReifiedGetter s b
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s b -> ReifiedGetter s b)
    -> Getter s b -> ReifiedGetter s b
    forall a b. (a -> b) -> a -> b
    $ (s -> b) -> Optic' (->) f s b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> b) -> Optic' (->) f s b) -> (s -> b) -> Optic' (->) f s b
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (a -> b) s (a -> b) -> s -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting (a -> b) s (a -> b)
    Getter s (a -> b)
    mf s
    s (Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    ma s
    s)
      {-# INLINE (<.>) #-}
      m :: ReifiedGetter s a
    m <. :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a
    <. _ = ReifiedGetter s a
    m
      {-# INLINE (<.) #-}
      _ .> :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b
    .> m :: ReifiedGetter s b
    m = ReifiedGetter s b
    m
      {-# INLINE (.>) #-}

    instance Applicative (ReifiedGetter s) where
      pure :: a -> ReifiedGetter s a
    pure a :: a
    a = Getter s a -> ReifiedGetter s a
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s a -> ReifiedGetter s a)
    -> Getter s a -> ReifiedGetter s a
    forall a b. (a -> b) -> a -> b
    $ (s -> a) -> Optic' (->) f s a
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> a) -> Optic' (->) f s a) -> (s -> a) -> Optic' (->) f s a
    forall a b. (a -> b) -> a -> b
    $ \_ -> a
    a
      {-# INLINE pure #-}
      Getter mf :: Getter s (a -> b)
    mf <*> :: ReifiedGetter s (a -> b) -> ReifiedGetter s a -> ReifiedGetter s b
    <*> Getter ma :: Getter s a
    ma = Getter s b -> ReifiedGetter s b
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s b -> ReifiedGetter s b)
    -> Getter s b -> ReifiedGetter s b
    forall a b. (a -> b) -> a -> b
    $ (s -> b) -> Optic' (->) f s b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> b) -> Optic' (->) f s b) -> (s -> b) -> Optic' (->) f s b
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (a -> b) s (a -> b) -> s -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting (a -> b) s (a -> b)
    Getter s (a -> b)
    mf s
    s (Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    ma s
    s)
      {-# INLINE (<*>) #-}
      m :: ReifiedGetter s a
    m <* :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s a
    <* _ = ReifiedGetter s a
    m
      {-# INLINE (<*) #-}
      _ *> :: ReifiedGetter s a -> ReifiedGetter s b -> ReifiedGetter s b
    *> m :: ReifiedGetter s b
    m = ReifiedGetter s b
    m
      {-# INLINE (*>) #-}

    instance Bind (ReifiedGetter s) where
      Getter ma :: Getter s a
    ma >>- :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b
    >>- f :: a -> ReifiedGetter s b
    f = Getter s b -> ReifiedGetter s b
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s b -> ReifiedGetter s b)
    -> Getter s b -> ReifiedGetter s b
    forall a b. (a -> b) -> a -> b
    $ (s -> b) -> Optic' (->) f s b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> b) -> Optic' (->) f s b) -> (s -> b) -> Optic' (->) f s b
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting b s b -> s -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (ReifiedGetter s b -> Getter s b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter (a -> ReifiedGetter s b
    f (Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    ma s
    s))) s
    s
      {-# INLINE (>>-) #-}

    instance Monad (ReifiedGetter s) where
      return :: a -> ReifiedGetter s a
    return = a -> ReifiedGetter s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
      {-# INLINE return #-}
      Getter ma :: Getter s a
    ma >>= :: ReifiedGetter s a -> (a -> ReifiedGetter s b) -> ReifiedGetter s b
    >>= f :: a -> ReifiedGetter s b
    f = Getter s b -> ReifiedGetter s b
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter s b -> ReifiedGetter s b)
    -> Getter s b -> ReifiedGetter s b
    forall a b. (a -> b) -> a -> b
    $ (s -> b) -> Optic' (->) f s b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((s -> b) -> Optic' (->) f s b) -> (s -> b) -> Optic' (->) f s b
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting b s b -> s -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (ReifiedGetter s b -> Getter s b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter (a -> ReifiedGetter s b
    f (Getting a s a -> s -> a
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting a s a
    Getter s a
    ma s
    s))) s
    s
      {-# INLINE (>>=) #-}

    instance MonadReader s (ReifiedGetter s) where
      ask :: ReifiedGetter s s
    ask = Getter s s -> ReifiedGetter s s
    forall s a. Getter s a -> ReifiedGetter s a
    Getter forall a. a -> a
    Getter s s
    id
      {-# INLINE ask #-}
      local :: (s -> s) -> ReifiedGetter s a -> ReifiedGetter s a
    local f :: s -> s
    f m :: ReifiedGetter s a
    m = Getter s a -> ReifiedGetter s a
    forall s a. Getter s a -> ReifiedGetter s a
    Getter ((s -> s) -> Optic' (->) f s s
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to s -> s
    f Optic' (->) f s s
    -> ((a -> f a) -> s -> f s) -> (a -> f a) -> s -> f s
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedGetter s a -> Getter s a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter s a
    m)
      {-# INLINE local #-}

    instance Profunctor ReifiedGetter where
      dimap :: (a -> b) -> (c -> d) -> ReifiedGetter b c -> ReifiedGetter a d
    dimap f :: a -> b
    f g :: c -> d
    g l :: ReifiedGetter b c
    l = Getter a d -> ReifiedGetter a d
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter a d -> ReifiedGetter a d)
    -> Getter a d -> ReifiedGetter a d
    forall a b. (a -> b) -> a -> b
    $ (a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    fOptic' (->) f a b
    -> ((d -> f d) -> b -> f b) -> (d -> f d) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .ReifiedGetter b c
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter b c
    l((c -> f c) -> b -> f b)
    -> ((d -> f d) -> c -> f c) -> (d -> f d) -> b -> f b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(c -> d) -> (d -> f d) -> c -> f c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to c -> d
    g
      {-# INLINE dimap #-}
      lmap :: (a -> b) -> ReifiedGetter b c -> ReifiedGetter a c
    lmap g :: a -> b
    g l :: ReifiedGetter b c
    l    = Getter a c -> ReifiedGetter a c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter a c -> ReifiedGetter a c)
    -> Getter a c -> ReifiedGetter a c
    forall a b. (a -> b) -> a -> b
    $ (a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    gOptic' (->) f a b
    -> ((c -> f c) -> b -> f b) -> (c -> f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .ReifiedGetter b c
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter b c
    l
      {-# INLINE lmap #-}
      rmap :: (b -> c) -> ReifiedGetter a b -> ReifiedGetter a c
    rmap f :: b -> c
    f l :: ReifiedGetter a b
    l    = Getter a c -> ReifiedGetter a c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter a c -> ReifiedGetter a c)
    -> Getter a c -> ReifiedGetter a c
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter a b
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (b -> f b) -> a -> f a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter a b
    l((b -> f b) -> a -> f a)
    -> ((c -> f c) -> b -> f b) -> (c -> f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(b -> c) -> (c -> f c) -> b -> f b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to b -> c
    f
      {-# INLINE rmap #-}

    instance Closed ReifiedGetter where
      closed :: ReifiedGetter a b -> ReifiedGetter (x -> a) (x -> b)
    closed l :: ReifiedGetter a b
    l = Getter (x -> a) (x -> b) -> ReifiedGetter (x -> a) (x -> b)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (x -> a) (x -> b) -> ReifiedGetter (x -> a) (x -> b))
    -> Getter (x -> a) (x -> b) -> ReifiedGetter (x -> a) (x -> b)
    forall a b. (a -> b) -> a -> b
    $ ((x -> a) -> x -> b) -> Optic' (->) f (x -> a) (x -> b)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to (((x -> a) -> x -> b) -> Optic' (->) f (x -> a) (x -> b))
    -> ((x -> a) -> x -> b) -> Optic' (->) f (x -> a) (x -> b)
    forall a b. (a -> b) -> a -> b
    $ \f :: x -> a
    f -> Getting b a b -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (ReifiedGetter a b
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (b -> f b) -> a -> f a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter a b
    l) (a -> b) -> (x -> a) -> x -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . x -> a
    f

    instance Cosieve ReifiedGetter Identity where
      cosieve :: ReifiedGetter a b -> Identity a -> b
    cosieve (Getter l :: Getter a b
    l) = Getting b a b -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting b a b
    Getter a b
    l (a -> b) -> (Identity a -> a) -> Identity a -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Identity a -> a
    forall a. Identity a -> a
    runIdentity

    instance Corepresentable ReifiedGetter where
      type Corep ReifiedGetter = Identity
      cotabulate :: (Corep ReifiedGetter d -> c) -> ReifiedGetter d c
    cotabulate f :: Corep ReifiedGetter d -> c
    f = Getter d c -> ReifiedGetter d c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter d c -> ReifiedGetter d c)
    -> Getter d c -> ReifiedGetter d c
    forall a b. (a -> b) -> a -> b
    $ (d -> c) -> Optic' (->) f d c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to (Identity d -> c
    Corep ReifiedGetter d -> c
    f (Identity d -> c) -> (d -> Identity d) -> d -> c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> Identity d
    forall a. a -> Identity a
    Identity)

    instance Sieve ReifiedGetter Identity where
      sieve :: ReifiedGetter a b -> a -> Identity b
    sieve (Getter l :: Getter a b
    l) = b -> Identity b
    forall a. a -> Identity a
    Identity (b -> Identity b) -> (a -> b) -> a -> Identity b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Getting b a b -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting b a b
    Getter a b
    l

    instance Representable ReifiedGetter where
      type Rep ReifiedGetter = Identity
      tabulate :: (d -> Rep ReifiedGetter c) -> ReifiedGetter d c
    tabulate f :: d -> Rep ReifiedGetter c
    f = Getter d c -> ReifiedGetter d c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter d c -> ReifiedGetter d c)
    -> Getter d c -> ReifiedGetter d c
    forall a b. (a -> b) -> a -> b
    $ (d -> c) -> Optic' (->) f d c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to (Identity c -> c
    forall a. Identity a -> a
    runIdentity (Identity c -> c) -> (d -> Identity c) -> d -> c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> Identity c
    d -> Rep ReifiedGetter c
    f)

    instance Costrong ReifiedGetter where
      unfirst :: ReifiedGetter (a, d) (b, d) -> ReifiedGetter a b
    unfirst l :: ReifiedGetter (a, d) (b, d)
    l = Getter a b -> ReifiedGetter a b
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter a b -> ReifiedGetter a b)
    -> Getter a b -> ReifiedGetter a b
    forall a b. (a -> b) -> a -> b
    $ (a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((a -> b) -> Optic' (->) f a b) -> (a -> b) -> Optic' (->) f a b
    forall a b. (a -> b) -> a -> b
    $ ((a, d) -> (b, d)) -> a -> b
    forall (p :: * -> * -> *) a d b.
    Costrong p =>
    p (a, d) (b, d) -> p a b
    unfirst (((a, d) -> (b, d)) -> a -> b) -> ((a, d) -> (b, d)) -> a -> b
    forall a b. (a -> b) -> a -> b
    $ Getting (b, d) (a, d) (b, d) -> (a, d) -> (b, d)
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (ReifiedGetter (a, d) (b, d)
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       ((b, d) -> f (b, d)) -> (a, d) -> f (a, d)
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter (a, d) (b, d)
    l)

    instance Conjoined ReifiedGetter

    instance Strong ReifiedGetter where
      first' :: ReifiedGetter a b -> ReifiedGetter (a, c) (b, c)
    first' l :: ReifiedGetter a b
    l = Getter (a, c) (b, c) -> ReifiedGetter (a, c) (b, c)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (a, c) (b, c) -> ReifiedGetter (a, c) (b, c))
    -> Getter (a, c) (b, c) -> ReifiedGetter (a, c) (b, c)
    forall a b. (a -> b) -> a -> b
    $ \f :: (b, c) -> f (b, c)
    f (s,c) ->
        f a -> f (a, c)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (a, c)) -> f a -> f (a, c)
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter a b -> (b -> f b) -> a -> f a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter a b
    l ((b -> (b, c))
    -> (f (b, c) -> f b) -> ((b, c) -> f (b, c)) -> b -> f b
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((b -> c -> (b, c)) -> c -> b -> (b, c)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (,) c
    c) f (b, c) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (b, c) -> f (b, c)
    f) a
    s
      {-# INLINE first' #-}
      second' :: ReifiedGetter a b -> ReifiedGetter (c, a) (c, b)
    second' l :: ReifiedGetter a b
    l = Getter (c, a) (c, b) -> ReifiedGetter (c, a) (c, b)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (c, a) (c, b) -> ReifiedGetter (c, a) (c, b))
    -> Getter (c, a) (c, b) -> ReifiedGetter (c, a) (c, b)
    forall a b. (a -> b) -> a -> b
    $ \f :: (c, b) -> f (c, b)
    f (c,s) ->
        f a -> f (c, a)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (c, a)) -> f a -> f (c, a)
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter a b -> (b -> f b) -> a -> f a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter a b
    l ((b -> (c, b))
    -> (f (c, b) -> f b) -> ((c, b) -> f (c, b)) -> b -> f b
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((,) c
    c) f (c, b) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (c, b) -> f (c, b)
    f) a
    s
      {-# INLINE second' #-}

    instance Choice ReifiedGetter where
      left' :: ReifiedGetter a b -> ReifiedGetter (Either a c) (Either b c)
    left' l :: ReifiedGetter a b
    l = Getter (Either a c) (Either b c)
    -> ReifiedGetter (Either a c) (Either b c)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (Either a c) (Either b c)
     -> ReifiedGetter (Either a c) (Either b c))
    -> Getter (Either a c) (Either b c)
    -> ReifiedGetter (Either a c) (Either b c)
    forall a b. (a -> b) -> a -> b
    $ (Either a c -> Either b c)
    -> Optic' (->) f (Either a c) (Either b c)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((Either a c -> Either b c)
     -> Optic' (->) f (Either a c) (Either b c))
    -> (Either a c -> Either b c)
    -> Optic' (->) f (Either a c) (Either b c)
    forall a b. (a -> b) -> a -> b
    $ (a -> b) -> Either a c -> Either b c
    forall (p :: * -> * -> *) a b c.
    Choice p =>
    p a b -> p (Either a c) (Either b c)
    left' ((a -> b) -> Either a c -> Either b c)
    -> (a -> b) -> Either a c -> Either b c
    forall a b. (a -> b) -> a -> b
    $ Getting b a b -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (Getting b a b -> a -> b) -> Getting b a b -> a -> b
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter a b
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (b -> f b) -> a -> f a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter a b
    l
      {-# INLINE left' #-}
      right' :: ReifiedGetter a b -> ReifiedGetter (Either c a) (Either c b)
    right' l :: ReifiedGetter a b
    l = Getter (Either c a) (Either c b)
    -> ReifiedGetter (Either c a) (Either c b)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (Either c a) (Either c b)
     -> ReifiedGetter (Either c a) (Either c b))
    -> Getter (Either c a) (Either c b)
    -> ReifiedGetter (Either c a) (Either c b)
    forall a b. (a -> b) -> a -> b
    $ (Either c a -> Either c b)
    -> Optic' (->) f (Either c a) (Either c b)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((Either c a -> Either c b)
     -> Optic' (->) f (Either c a) (Either c b))
    -> (Either c a -> Either c b)
    -> Optic' (->) f (Either c a) (Either c b)
    forall a b. (a -> b) -> a -> b
    $ (a -> b) -> Either c a -> Either c b
    forall (p :: * -> * -> *) a b c.
    Choice p =>
    p a b -> p (Either c a) (Either c b)
    right' ((a -> b) -> Either c a -> Either c b)
    -> (a -> b) -> Either c a -> Either c b
    forall a b. (a -> b) -> a -> b
    $ Getting b a b -> a -> b
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (Getting b a b -> a -> b) -> Getting b a b -> a -> b
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter a b
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (b -> f b) -> a -> f a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter a b
    l
      {-# INLINE right' #-}

    instance Cat.Category ReifiedGetter where
      id :: ReifiedGetter a a
    id = Getter a a -> ReifiedGetter a a
    forall s a. Getter s a -> ReifiedGetter s a
    Getter forall a. a -> a
    Getter a a
    id
      l :: ReifiedGetter b c
    l . :: ReifiedGetter b c -> ReifiedGetter a b -> ReifiedGetter a c
    . r :: ReifiedGetter a b
    r = Getter a c -> ReifiedGetter a c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (ReifiedGetter a b
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (b -> f b) -> a -> f a
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter a b
    r((b -> f b) -> a -> f a)
    -> ((c -> f c) -> b -> f b) -> (c -> f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .ReifiedGetter b c
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter b c
    l)
      {-# INLINE (.) #-}

    instance Arrow ReifiedGetter where
      arr :: (b -> c) -> ReifiedGetter b c
    arr f :: b -> c
    f = Getter b c -> ReifiedGetter b c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter ((b -> c) -> Optic' (->) f b c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to b -> c
    f)
      {-# INLINE arr #-}
      first :: ReifiedGetter b c -> ReifiedGetter (b, d) (c, d)
    first l :: ReifiedGetter b c
    l = Getter (b, d) (c, d) -> ReifiedGetter (b, d) (c, d)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (b, d) (c, d) -> ReifiedGetter (b, d) (c, d))
    -> Getter (b, d) (c, d) -> ReifiedGetter (b, d) (c, d)
    forall a b. (a -> b) -> a -> b
    $ ((b, d) -> (c, d)) -> Optic' (->) f (b, d) (c, d)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to (((b, d) -> (c, d)) -> Optic' (->) f (b, d) (c, d))
    -> ((b, d) -> (c, d)) -> Optic' (->) f (b, d) (c, d)
    forall a b. (a -> b) -> a -> b
    $ (b -> c) -> (b, d) -> (c, d)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    first ((b -> c) -> (b, d) -> (c, d)) -> (b -> c) -> (b, d) -> (c, d)
    forall a b. (a -> b) -> a -> b
    $ Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (Getting c b c -> b -> c) -> Getting c b c -> b -> c
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter b c
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter b c
    l
      {-# INLINE first #-}
      second :: ReifiedGetter b c -> ReifiedGetter (d, b) (d, c)
    second l :: ReifiedGetter b c
    l = Getter (d, b) (d, c) -> ReifiedGetter (d, b) (d, c)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (d, b) (d, c) -> ReifiedGetter (d, b) (d, c))
    -> Getter (d, b) (d, c) -> ReifiedGetter (d, b) (d, c)
    forall a b. (a -> b) -> a -> b
    $ ((d, b) -> (d, c)) -> Optic' (->) f (d, b) (d, c)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to (((d, b) -> (d, c)) -> Optic' (->) f (d, b) (d, c))
    -> ((d, b) -> (d, c)) -> Optic' (->) f (d, b) (d, c)
    forall a b. (a -> b) -> a -> b
    $ (b -> c) -> (d, b) -> (d, c)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    second ((b -> c) -> (d, b) -> (d, c)) -> (b -> c) -> (d, b) -> (d, c)
    forall a b. (a -> b) -> a -> b
    $ Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (Getting c b c -> b -> c) -> Getting c b c -> b -> c
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter b c
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter b c
    l
      {-# INLINE second #-}
      Getter l :: Getter b c
    l *** :: ReifiedGetter b c
    -> ReifiedGetter b' c' -> ReifiedGetter (b, b') (c, c')
    *** Getter r :: Getter b' c'
    r = Getter (b, b') (c, c') -> ReifiedGetter (b, b') (c, c')
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (b, b') (c, c') -> ReifiedGetter (b, b') (c, c'))
    -> Getter (b, b') (c, c') -> ReifiedGetter (b, b') (c, c')
    forall a b. (a -> b) -> a -> b
    $ ((b, b') -> (c, c')) -> Optic' (->) f (b, b') (c, c')
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to (((b, b') -> (c, c')) -> Optic' (->) f (b, b') (c, c'))
    -> ((b, b') -> (c, c')) -> Optic' (->) f (b, b') (c, c')
    forall a b. (a -> b) -> a -> b
    $ Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting c b c
    Getter b c
    l (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
    forall (a :: * -> * -> *) b c b' c'.
    Arrow a =>
    a b c -> a b' c' -> a (b, b') (c, c')
    *** Getting c' b' c' -> b' -> c'
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting c' b' c'
    Getter b' c'
    r
      {-# INLINE (***) #-}
      Getter l :: Getter b c
    l &&& :: ReifiedGetter b c -> ReifiedGetter b c' -> ReifiedGetter b (c, c')
    &&& Getter r :: Getter b c'
    r = Getter b (c, c') -> ReifiedGetter b (c, c')
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter b (c, c') -> ReifiedGetter b (c, c'))
    -> Getter b (c, c') -> ReifiedGetter b (c, c')
    forall a b. (a -> b) -> a -> b
    $ (b -> (c, c')) -> Optic' (->) f b (c, c')
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((b -> (c, c')) -> Optic' (->) f b (c, c'))
    -> (b -> (c, c')) -> Optic' (->) f b (c, c')
    forall a b. (a -> b) -> a -> b
    $ Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting c b c
    Getter b c
    l (b -> c) -> (b -> c') -> b -> (c, c')
    forall (a :: * -> * -> *) b c c'.
    Arrow a =>
    a b c -> a b c' -> a b (c, c')
    &&& Getting c' b c' -> b -> c'
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting c' b c'
    Getter b c'
    r
      {-# INLINE (&&&) #-}

    instance ArrowApply ReifiedGetter where
      app :: ReifiedGetter (ReifiedGetter b c, b) c
    app = Getter (ReifiedGetter b c, b) c
    -> ReifiedGetter (ReifiedGetter b c, b) c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (ReifiedGetter b c, b) c
     -> ReifiedGetter (ReifiedGetter b c, b) c)
    -> Getter (ReifiedGetter b c, b) c
    -> ReifiedGetter (ReifiedGetter b c, b) c
    forall a b. (a -> b) -> a -> b
    $ ((ReifiedGetter b c, b) -> c)
    -> Optic' (->) f (ReifiedGetter b c, b) c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to (((ReifiedGetter b c, b) -> c)
     -> Optic' (->) f (ReifiedGetter b c, b) c)
    -> ((ReifiedGetter b c, b) -> c)
    -> Optic' (->) f (ReifiedGetter b c, b) c
    forall a b. (a -> b) -> a -> b
    $ \(Getter bc :: Getter b c
    bc, b :: b
    b) -> Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting c b c
    Getter b c
    bc b
    b
      {-# INLINE app #-}

    instance ArrowChoice ReifiedGetter where
      left :: ReifiedGetter b c -> ReifiedGetter (Either b d) (Either c d)
    left l :: ReifiedGetter b c
    l = Getter (Either b d) (Either c d)
    -> ReifiedGetter (Either b d) (Either c d)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (Either b d) (Either c d)
     -> ReifiedGetter (Either b d) (Either c d))
    -> Getter (Either b d) (Either c d)
    -> ReifiedGetter (Either b d) (Either c d)
    forall a b. (a -> b) -> a -> b
    $ (Either b d -> Either c d)
    -> Optic' (->) f (Either b d) (Either c d)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((Either b d -> Either c d)
     -> Optic' (->) f (Either b d) (Either c d))
    -> (Either b d -> Either c d)
    -> Optic' (->) f (Either b d) (Either c d)
    forall a b. (a -> b) -> a -> b
    $ (b -> c) -> Either b d -> Either c d
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either b d) (Either c d)
    left ((b -> c) -> Either b d -> Either c d)
    -> (b -> c) -> Either b d -> Either c d
    forall a b. (a -> b) -> a -> b
    $ Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (Getting c b c -> b -> c) -> Getting c b c -> b -> c
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter b c
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter b c
    l
      {-# INLINE left #-}
      right :: ReifiedGetter b c -> ReifiedGetter (Either d b) (Either d c)
    right l :: ReifiedGetter b c
    l = Getter (Either d b) (Either d c)
    -> ReifiedGetter (Either d b) (Either d c)
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (Either d b) (Either d c)
     -> ReifiedGetter (Either d b) (Either d c))
    -> Getter (Either d b) (Either d c)
    -> ReifiedGetter (Either d b) (Either d c)
    forall a b. (a -> b) -> a -> b
    $ (Either d b -> Either d c)
    -> Optic' (->) f (Either d b) (Either d c)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((Either d b -> Either d c)
     -> Optic' (->) f (Either d b) (Either d c))
    -> (Either d b -> Either d c)
    -> Optic' (->) f (Either d b) (Either d c)
    forall a b. (a -> b) -> a -> b
    $ (b -> c) -> Either d b -> Either d c
    forall (a :: * -> * -> *) b c d.
    ArrowChoice a =>
    a b c -> a (Either d b) (Either d c)
    right ((b -> c) -> Either d b -> Either d c)
    -> (b -> c) -> Either d b -> Either d c
    forall a b. (a -> b) -> a -> b
    $ Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (Getting c b c -> b -> c) -> Getting c b c -> b -> c
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter b c
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter b c
    l
      {-# INLINE right #-}
      Getter l :: Getter b c
    l +++ :: ReifiedGetter b c
    -> ReifiedGetter b' c' -> ReifiedGetter (Either b b') (Either c c')
    +++ Getter r :: Getter b' c'
    r = Getter (Either b b') (Either c c')
    -> ReifiedGetter (Either b b') (Either c c')
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (Either b b') (Either c c')
     -> ReifiedGetter (Either b b') (Either c c'))
    -> Getter (Either b b') (Either c c')
    -> ReifiedGetter (Either b b') (Either c c')
    forall a b. (a -> b) -> a -> b
    $ (Either b b' -> Either c c')
    -> Optic' (->) f (Either b b') (Either c c')
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((Either b b' -> Either c c')
     -> Optic' (->) f (Either b b') (Either c c'))
    -> (Either b b' -> Either c c')
    -> Optic' (->) f (Either b b') (Either c c')
    forall a b. (a -> b) -> a -> b
    $ Getting c b c -> b -> c
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting c b c
    Getter b c
    l (b -> c) -> (b' -> c') -> Either b b' -> Either c c'
    forall (a :: * -> * -> *) b c b' c'.
    ArrowChoice a =>
    a b c -> a b' c' -> a (Either b b') (Either c c')
    +++ Getting c' b' c' -> b' -> c'
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting c' b' c'
    Getter b' c'
    r
      {-# INLINE (+++) #-}
      Getter l :: Getter b d
    l ||| :: ReifiedGetter b d
    -> ReifiedGetter c d -> ReifiedGetter (Either b c) d
    ||| Getter r :: Getter c d
    r = Getter (Either b c) d -> ReifiedGetter (Either b c) d
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter (Either b c) d -> ReifiedGetter (Either b c) d)
    -> Getter (Either b c) d -> ReifiedGetter (Either b c) d
    forall a b. (a -> b) -> a -> b
    $ (Either b c -> d) -> Optic' (->) f (Either b c) d
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((Either b c -> d) -> Optic' (->) f (Either b c) d)
    -> (Either b c -> d) -> Optic' (->) f (Either b c) d
    forall a b. (a -> b) -> a -> b
    $ Getting d b d -> b -> d
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting d b d
    Getter b d
    l (b -> d) -> (c -> d) -> Either b c -> d
    forall (a :: * -> * -> *) b d c.
    ArrowChoice a =>
    a b d -> a c d -> a (Either b c) d
    ||| Getting d c d -> c -> d
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view Getting d c d
    Getter c d
    r
      {-# INLINE (|||) #-}

    instance ArrowLoop ReifiedGetter where
      loop :: ReifiedGetter (b, d) (c, d) -> ReifiedGetter b c
    loop l :: ReifiedGetter (b, d) (c, d)
    l = Getter b c -> ReifiedGetter b c
    forall s a. Getter s a -> ReifiedGetter s a
    Getter (Getter b c -> ReifiedGetter b c)
    -> Getter b c -> ReifiedGetter b c
    forall a b. (a -> b) -> a -> b
    $ (b -> c) -> Optic' (->) f b c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to ((b -> c) -> Optic' (->) f b c) -> (b -> c) -> Optic' (->) f b c
    forall a b. (a -> b) -> a -> b
    $ ((b, d) -> (c, d)) -> b -> c
    forall (a :: * -> * -> *) b d c.
    ArrowLoop a =>
    a (b, d) (c, d) -> a b c
    loop (((b, d) -> (c, d)) -> b -> c) -> ((b, d) -> (c, d)) -> b -> c
    forall a b. (a -> b) -> a -> b
    $ Getting (c, d) (b, d) (c, d) -> (b, d) -> (c, d)
    forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
    view (Getting (c, d) (b, d) (c, d) -> (b, d) -> (c, d))
    -> Getting (c, d) (b, d) (c, d) -> (b, d) -> (c, d)
    forall a b. (a -> b) -> a -> b
    $ ReifiedGetter (b, d) (c, d)
    -> forall (f :: * -> *).
       (Contravariant f, Functor f) =>
       ((c, d) -> f (c, d)) -> (b, d) -> f (b, d)
    forall s a. ReifiedGetter s a -> Getter s a
    runGetter ReifiedGetter (b, d) (c, d)
    l
      {-# INLINE loop #-}

    ------------------------------------------------------------------------------
    -- IndexedGetter
    ------------------------------------------------------------------------------

    -- | Reify an 'IndexedGetter' so it can be stored safely in a container.
    newtype ReifiedIndexedGetter i s a = IndexedGetter { ReifiedIndexedGetter i s a
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Functor f) =>
       p a (f a) -> s -> f s
    runIndexedGetter :: IndexedGetter i s a }

    instance Profunctor (ReifiedIndexedGetter i) where
      dimap :: (a -> b)
    -> (c -> d)
    -> ReifiedIndexedGetter i b c
    -> ReifiedIndexedGetter i a d
    dimap f :: a -> b
    f g :: c -> d
    g l :: ReifiedIndexedGetter i b c
    l = IndexedGetter i a d -> ReifiedIndexedGetter i a d
    forall i s a. IndexedGetter i s a -> ReifiedIndexedGetter i s a
    IndexedGetter ((a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f Optic' (->) f a b
    -> (p d (f d) -> b -> f b) -> p d (f d) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedIndexedGetter i b c
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Functor f) =>
       p c (f c) -> b -> f b
    forall i s a. ReifiedIndexedGetter i s a -> IndexedGetter i s a
    runIndexedGetter ReifiedIndexedGetter i b c
    l (p c (f c) -> b -> f b)
    -> (p d (f d) -> p c (f c)) -> p d (f d) -> b -> f b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (c -> d) -> p d (f d) -> p c (f c)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to c -> d
    g)
      {-# INLINE dimap #-}

    instance Sieve (ReifiedIndexedGetter i) ((,) i) where
      sieve :: ReifiedIndexedGetter i a b -> a -> (i, b)
    sieve = IndexedGetting i (i, b) a b -> a -> (i, b)
    forall s (m :: * -> *) i a.
    MonadReader s m =>
    IndexedGetting i (i, a) s a -> m (i, a)
    iview (IndexedGetting i (i, b) a b -> a -> (i, b))
    -> (ReifiedIndexedGetter i a b -> IndexedGetting i (i, b) a b)
    -> ReifiedIndexedGetter i a b
    -> a
    -> (i, b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedIndexedGetter i a b -> IndexedGetting i (i, b) a b
    forall i s a. ReifiedIndexedGetter i s a -> IndexedGetter i s a
    runIndexedGetter
      {-# INLINE sieve #-}

    instance Representable (ReifiedIndexedGetter i) where
      type Rep (ReifiedIndexedGetter i) = (,) i
      tabulate :: (d -> Rep (ReifiedIndexedGetter i) c) -> ReifiedIndexedGetter i d c
    tabulate f :: d -> Rep (ReifiedIndexedGetter i) c
    f = IndexedGetter i d c -> ReifiedIndexedGetter i d c
    forall i s a. IndexedGetter i s a -> ReifiedIndexedGetter i s a
    IndexedGetter (IndexedGetter i d c -> ReifiedIndexedGetter i d c)
    -> IndexedGetter i d c -> ReifiedIndexedGetter i d c
    forall a b. (a -> b) -> a -> b
    $ (d -> (i, c)) -> Over' p f d c
    forall i (p :: * -> * -> *) (f :: * -> *) s a.
    (Indexable i p, Contravariant f) =>
    (s -> (i, a)) -> Over' p f s a
    ito d -> (i, c)
    d -> Rep (ReifiedIndexedGetter i) c
    f
      {-# INLINE tabulate #-}

    instance Strong (ReifiedIndexedGetter i) where
      first' :: ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i (a, c) (b, c)
    first' l :: ReifiedIndexedGetter i a b
    l = IndexedGetter i (a, c) (b, c)
    -> ReifiedIndexedGetter i (a, c) (b, c)
    forall i s a. IndexedGetter i s a -> ReifiedIndexedGetter i s a
    IndexedGetter (IndexedGetter i (a, c) (b, c)
     -> ReifiedIndexedGetter i (a, c) (b, c))
    -> IndexedGetter i (a, c) (b, c)
    -> ReifiedIndexedGetter i (a, c) (b, c)
    forall a b. (a -> b) -> a -> b
    $ \f :: p (b, c) (f (b, c))
    f (s,c) ->
        f a -> f (a, c)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (a, c)) -> f a -> f (a, c)
    forall a b. (a -> b) -> a -> b
    $ ReifiedIndexedGetter i a b -> p b (f b) -> a -> f a
    forall i s a. ReifiedIndexedGetter i s a -> IndexedGetter i s a
    runIndexedGetter ReifiedIndexedGetter i a b
    l ((b -> (b, c))
    -> (f (b, c) -> f b) -> p (b, c) (f (b, c)) -> p b (f b)
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((b -> c -> (b, c)) -> c -> b -> (b, c)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (,) c
    c) f (b, c) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom p (b, c) (f (b, c))
    f) a
    s
      {-# INLINE first' #-}
      second' :: ReifiedIndexedGetter i a b -> ReifiedIndexedGetter i (c, a) (c, b)
    second' l :: ReifiedIndexedGetter i a b
    l = IndexedGetter i (c, a) (c, b)
    -> ReifiedIndexedGetter i (c, a) (c, b)
    forall i s a. IndexedGetter i s a -> ReifiedIndexedGetter i s a
    IndexedGetter (IndexedGetter i (c, a) (c, b)
     -> ReifiedIndexedGetter i (c, a) (c, b))
    -> IndexedGetter i (c, a) (c, b)
    -> ReifiedIndexedGetter i (c, a) (c, b)
    forall a b. (a -> b) -> a -> b
    $ \f :: p (c, b) (f (c, b))
    f (c,s) ->
        f a -> f (c, a)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (c, a)) -> f a -> f (c, a)
    forall a b. (a -> b) -> a -> b
    $ ReifiedIndexedGetter i a b -> p b (f b) -> a -> f a
    forall i s a. ReifiedIndexedGetter i s a -> IndexedGetter i s a
    runIndexedGetter ReifiedIndexedGetter i a b
    l ((b -> (c, b))
    -> (f (c, b) -> f b) -> p (c, b) (f (c, b)) -> p b (f b)
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((,) c
    c) f (c, b) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom p (c, b) (f (c, b))
    f) a
    s
      {-# INLINE second' #-}

    instance Functor (ReifiedIndexedGetter i s) where
      fmap :: (a -> b)
    -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b
    fmap f :: a -> b
    f l :: ReifiedIndexedGetter i s a
    l = IndexedGetter i s b -> ReifiedIndexedGetter i s b
    forall i s a. IndexedGetter i s a -> ReifiedIndexedGetter i s a
    IndexedGetter (ReifiedIndexedGetter i s a
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Functor f) =>
       p a (f a) -> s -> f s
    forall i s a. ReifiedIndexedGetter i s a -> IndexedGetter i s a
    runIndexedGetter ReifiedIndexedGetter i s a
    l(p a (f a) -> s -> f s)
    -> (p b (f b) -> p a (f a)) -> p b (f b) -> s -> f s
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(a -> b) -> p b (f b) -> p a (f a)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f)
      {-# INLINE fmap #-}

    instance Semigroup i => Apply (ReifiedIndexedGetter i s) where
      IndexedGetter mf :: IndexedGetter i s (a -> b)
    mf <.> :: ReifiedIndexedGetter i s (a -> b)
    -> ReifiedIndexedGetter i s a -> ReifiedIndexedGetter i s b
    <.> IndexedGetter ma :: IndexedGetter i s a
    ma = IndexedGetter i s b -> ReifiedIndexedGetter i s b
    forall i s a. IndexedGetter i s a -> ReifiedIndexedGetter i s a
    IndexedGetter (IndexedGetter i s b -> ReifiedIndexedGetter i s b)
    -> IndexedGetter i s b -> ReifiedIndexedGetter i s b
    forall a b. (a -> b) -> a -> b
    $ \k :: p b (f b)
    k s :: s
    s ->
        case IndexedGetting i (i, a -> b) s (a -> b) -> s -> (i, a -> b)
    forall s (m :: * -> *) i a.
    MonadReader s m =>
    IndexedGetting i (i, a) s a -> m (i, a)
    iview IndexedGetting i (i, a -> b) s (a -> b)
    IndexedGetter i s (a -> b)
    mf s
    s of
          (i :: i
    i, f :: a -> b
    f) -> case IndexedGetting i (i, a) s a -> s -> (i, a)
    forall s (m :: * -> *) i a.
    MonadReader s m =>
    IndexedGetting i (i, a) s a -> m (i, a)
    iview IndexedGetting i (i, a) s a
    IndexedGetter i s a
    ma s
    s of
            (j :: i
    j, a :: a
    a) -> f b -> f s
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f b -> f s) -> f b -> f s
    forall a b. (a -> b) -> a -> b
    $ p b (f b) -> i -> b -> f b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p b (f b)
    k (i
    i i -> i -> i
    forall a. Semigroup a => a -> a -> a
    <> i
    j) (a -> b
    f a
    a)
      {-# INLINE (<.>) #-}

    ------------------------------------------------------------------------------
    -- Fold
    ------------------------------------------------------------------------------

    -- | Reify a 'Fold' so it can be stored safely in a container.
    --
    -- This can also be useful for creatively combining folds as
    -- @'ReifiedFold' s@ is isomorphic to @ReaderT s []@ and provides similar
    -- instances.
    --
    -- >>> ("hello","world")^..runFold ((,) <$> Fold _2 <*> Fold both)
    -- [("world","hello"),("world","world")]
    newtype ReifiedFold s a = Fold { ReifiedFold s a
    -> forall (f :: * -> *).
       (Contravariant f, Applicative f) =>
       (a -> f a) -> s -> f s
    runFold :: Fold s a }

    instance Profunctor ReifiedFold where
      dimap :: (a -> b) -> (c -> d) -> ReifiedFold b c -> ReifiedFold a d
    dimap f :: a -> b
    f g :: c -> d
    g l :: ReifiedFold b c
    l = Fold a d -> ReifiedFold a d
    forall s a. Fold s a -> ReifiedFold s a
    Fold ((a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f Optic' (->) f a b
    -> ((d -> f d) -> b -> f b) -> (d -> f d) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedFold b c
    -> forall (f :: * -> *).
       (Contravariant f, Applicative f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold b c
    l ((c -> f c) -> b -> f b)
    -> ((d -> f d) -> c -> f c) -> (d -> f d) -> b -> f b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (c -> d) -> (d -> f d) -> c -> f c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to c -> d
    g)
      {-# INLINE dimap #-}
      rmap :: (b -> c) -> ReifiedFold a b -> ReifiedFold a c
    rmap g :: b -> c
    g l :: ReifiedFold a b
    l = Fold a c -> ReifiedFold a c
    forall s a. Fold s a -> ReifiedFold s a
    Fold (ReifiedFold a b
    -> forall (f :: * -> *).
       (Contravariant f, Applicative f) =>
       (b -> f b) -> a -> f a
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold a b
    l ((b -> f b) -> a -> f a)
    -> ((c -> f c) -> b -> f b) -> (c -> f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (b -> c) -> (c -> f c) -> b -> f b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to b -> c
    g)
      {-# INLINE rmap #-}
      lmap :: (a -> b) -> ReifiedFold b c -> ReifiedFold a c
    lmap f :: a -> b
    f l :: ReifiedFold b c
    l = Fold a c -> ReifiedFold a c
    forall s a. Fold s a -> ReifiedFold s a
    Fold ((a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f Optic' (->) f a b
    -> ((c -> f c) -> b -> f b) -> (c -> f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedFold b c
    -> forall (f :: * -> *).
       (Contravariant f, Applicative f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold b c
    l)
      {-# INLINE lmap #-}

    instance Sieve ReifiedFold [] where
      sieve :: ReifiedFold a b -> a -> [b]
    sieve = Getting (Endo [b]) a b -> a -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf (Getting (Endo [b]) a b -> a -> [b])
    -> (ReifiedFold a b -> Getting (Endo [b]) a b)
    -> ReifiedFold a b
    -> a
    -> [b]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedFold a b -> Getting (Endo [b]) a b
    forall s a. ReifiedFold s a -> Fold s a
    runFold

    instance Representable ReifiedFold where
      type Rep ReifiedFold = []
      tabulate :: (d -> Rep ReifiedFold c) -> ReifiedFold d c
    tabulate f :: d -> Rep ReifiedFold c
    f = Fold d c -> ReifiedFold d c
    forall s a. Fold s a -> ReifiedFold s a
    Fold ((d -> [c]) -> Fold d c
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding d -> [c]
    d -> Rep ReifiedFold c
    f)

    instance Strong ReifiedFold where
      first' :: ReifiedFold a b -> ReifiedFold (a, c) (b, c)
    first' l :: ReifiedFold a b
    l = Fold (a, c) (b, c) -> ReifiedFold (a, c) (b, c)
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold (a, c) (b, c) -> ReifiedFold (a, c) (b, c))
    -> Fold (a, c) (b, c) -> ReifiedFold (a, c) (b, c)
    forall a b. (a -> b) -> a -> b
    $ \f :: (b, c) -> f (b, c)
    f (s,c) ->
        f a -> f (a, c)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (a, c)) -> f a -> f (a, c)
    forall a b. (a -> b) -> a -> b
    $ ReifiedFold a b -> (b -> f b) -> a -> f a
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold a b
    l ((b -> (b, c))
    -> (f (b, c) -> f b) -> ((b, c) -> f (b, c)) -> b -> f b
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((b -> c -> (b, c)) -> c -> b -> (b, c)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (,) c
    c) f (b, c) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (b, c) -> f (b, c)
    f) a
    s
      {-# INLINE first' #-}
      second' :: ReifiedFold a b -> ReifiedFold (c, a) (c, b)
    second' l :: ReifiedFold a b
    l = Fold (c, a) (c, b) -> ReifiedFold (c, a) (c, b)
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold (c, a) (c, b) -> ReifiedFold (c, a) (c, b))
    -> Fold (c, a) (c, b) -> ReifiedFold (c, a) (c, b)
    forall a b. (a -> b) -> a -> b
    $ \f :: (c, b) -> f (c, b)
    f (c,s) ->
        f a -> f (c, a)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (c, a)) -> f a -> f (c, a)
    forall a b. (a -> b) -> a -> b
    $ ReifiedFold a b -> (b -> f b) -> a -> f a
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold a b
    l ((b -> (c, b))
    -> (f (c, b) -> f b) -> ((c, b) -> f (c, b)) -> b -> f b
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((,) c
    c) f (c, b) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (c, b) -> f (c, b)
    f) a
    s
      {-# INLINE second' #-}

    instance Choice ReifiedFold where
      left' :: ReifiedFold a b -> ReifiedFold (Either a c) (Either b c)
    left' (Fold l :: Fold a b
    l) = Fold (Either a c) (Either b c)
    -> ReifiedFold (Either a c) (Either b c)
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold (Either a c) (Either b c)
     -> ReifiedFold (Either a c) (Either b c))
    -> Fold (Either a c) (Either b c)
    -> ReifiedFold (Either a c) (Either b c)
    forall a b. (a -> b) -> a -> b
    $ (Either a c -> [Either b c])
    -> (Either b c -> f (Either b c)) -> Either a c -> f (Either a c)
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((Either a c -> [Either b c])
     -> (Either b c -> f (Either b c)) -> Either a c -> f (Either a c))
    -> (Either a c -> [Either b c])
    -> (Either b c -> f (Either b c))
    -> Either a c
    -> f (Either a c)
    forall a b. (a -> b) -> a -> b
    $ \esc :: Either a c
    esc -> case Either a c
    esc of
        Left s :: a
    s -> b -> Either b c
    forall a b. a -> Either a b
    Left (b -> Either b c) -> [b] -> [Either b c]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Getting (Endo [b]) a b -> a -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [b]) a b
    Fold a b
    l a
    s
        Right c :: c
    c -> [c -> Either b c
    forall a b. b -> Either a b
    Right c
    c]
      {-# INLINE left' #-}
      right' :: ReifiedFold a b -> ReifiedFold (Either c a) (Either c b)
    right' (Fold l :: Fold a b
    l) = Fold (Either c a) (Either c b)
    -> ReifiedFold (Either c a) (Either c b)
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold (Either c a) (Either c b)
     -> ReifiedFold (Either c a) (Either c b))
    -> Fold (Either c a) (Either c b)
    -> ReifiedFold (Either c a) (Either c b)
    forall a b. (a -> b) -> a -> b
    $ (Either c a -> [Either c b])
    -> (Either c b -> f (Either c b)) -> Either c a -> f (Either c a)
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((Either c a -> [Either c b])
     -> (Either c b -> f (Either c b)) -> Either c a -> f (Either c a))
    -> (Either c a -> [Either c b])
    -> (Either c b -> f (Either c b))
    -> Either c a
    -> f (Either c a)
    forall a b. (a -> b) -> a -> b
    $ \ecs :: Either c a
    ecs -> case Either c a
    ecs of
        Left c :: c
    c -> [c -> Either c b
    forall a b. a -> Either a b
    Left c
    c]
        Right s :: a
    s -> b -> Either c b
    forall a b. b -> Either a b
    Right (b -> Either c b) -> [b] -> [Either c b]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Getting (Endo [b]) a b -> a -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [b]) a b
    Fold a b
    l a
    s
      {-# INLINE right' #-}

    instance Cat.Category ReifiedFold where
      id :: ReifiedFold a a
    id = Fold a a -> ReifiedFold a a
    forall s a. Fold s a -> ReifiedFold s a
    Fold forall a. a -> a
    Fold a a
    id
      l :: ReifiedFold b c
    l . :: ReifiedFold b c -> ReifiedFold a b -> ReifiedFold a c
    . r :: ReifiedFold a b
    r = Fold a c -> ReifiedFold a c
    forall s a. Fold s a -> ReifiedFold s a
    Fold (ReifiedFold a b
    -> forall (f :: * -> *).
       (Contravariant f, Applicative f) =>
       (b -> f b) -> a -> f a
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold a b
    r ((b -> f b) -> a -> f a)
    -> ((c -> f c) -> b -> f b) -> (c -> f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedFold b c
    -> forall (f :: * -> *).
       (Contravariant f, Applicative f) =>
       (c -> f c) -> b -> f b
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold b c
    l)
      {-# INLINE (.) #-}

    instance Arrow ReifiedFold where
      arr :: (b -> c) -> ReifiedFold b c
    arr f :: b -> c
    f = Fold b c -> ReifiedFold b c
    forall s a. Fold s a -> ReifiedFold s a
    Fold ((b -> c) -> Optic' (->) f b c
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to b -> c
    f)
      {-# INLINE arr #-}
      first :: ReifiedFold b c -> ReifiedFold (b, d) (c, d)
    first = ReifiedFold b c -> ReifiedFold (b, d) (c, d)
    forall (p :: * -> * -> *) a b c.
    Strong p =>
    p a b -> p (a, c) (b, c)
    first'
      {-# INLINE first #-}
      second :: ReifiedFold b c -> ReifiedFold (d, b) (d, c)
    second = ReifiedFold b c -> ReifiedFold (d, b) (d, c)
    forall (p :: * -> * -> *) a b c.
    Strong p =>
    p a b -> p (c, a) (c, b)
    second'
      {-# INLINE second #-}
      Fold l :: Fold b c
    l *** :: ReifiedFold b c -> ReifiedFold b' c' -> ReifiedFold (b, b') (c, c')
    *** Fold r :: Fold b' c'
    r = Fold (b, b') (c, c') -> ReifiedFold (b, b') (c, c')
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold (b, b') (c, c') -> ReifiedFold (b, b') (c, c'))
    -> Fold (b, b') (c, c') -> ReifiedFold (b, b') (c, c')
    forall a b. (a -> b) -> a -> b
    $ ((b, b') -> [(c, c')])
    -> ((c, c') -> f (c, c')) -> (b, b') -> f (b, b')
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding (((b, b') -> [(c, c')])
     -> ((c, c') -> f (c, c')) -> (b, b') -> f (b, b'))
    -> ((b, b') -> [(c, c')])
    -> ((c, c') -> f (c, c'))
    -> (b, b')
    -> f (b, b')
    forall a b. (a -> b) -> a -> b
    $ \(x :: b
    x,y :: b'
    y) -> (,) (c -> c' -> (c, c')) -> [c] -> [c' -> (c, c')]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Getting (Endo [c]) b c -> b -> [c]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [c]) b c
    Fold b c
    l b
    x [c' -> (c, c')] -> [c'] -> [(c, c')]
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Getting (Endo [c']) b' c' -> b' -> [c']
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [c']) b' c'
    Fold b' c'
    r b'
    y
      {-# INLINE (***) #-}
      Fold l :: Fold b c
    l &&& :: ReifiedFold b c -> ReifiedFold b c' -> ReifiedFold b (c, c')
    &&& Fold r :: Fold b c'
    r = Fold b (c, c') -> ReifiedFold b (c, c')
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold b (c, c') -> ReifiedFold b (c, c'))
    -> Fold b (c, c') -> ReifiedFold b (c, c')
    forall a b. (a -> b) -> a -> b
    $ (b -> [(c, c')]) -> ((c, c') -> f (c, c')) -> b -> f b
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((b -> [(c, c')]) -> ((c, c') -> f (c, c')) -> b -> f b)
    -> (b -> [(c, c')]) -> ((c, c') -> f (c, c')) -> b -> f b
    forall a b. (a -> b) -> a -> b
    $ \x :: b
    x -> (,) (c -> c' -> (c, c')) -> [c] -> [c' -> (c, c')]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Getting (Endo [c]) b c -> b -> [c]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [c]) b c
    Fold b c
    l b
    x [c' -> (c, c')] -> [c'] -> [(c, c')]
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Getting (Endo [c']) b c' -> b -> [c']
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [c']) b c'
    Fold b c'
    r b
    x
      {-# INLINE (&&&) #-}

    instance ArrowChoice ReifiedFold where
      left :: ReifiedFold b c -> ReifiedFold (Either b d) (Either c d)
    left = ReifiedFold b c -> ReifiedFold (Either b d) (Either c d)
    forall (p :: * -> * -> *) a b c.
    Choice p =>
    p a b -> p (Either a c) (Either b c)
    left'
      {-# INLINE left #-}
      right :: ReifiedFold b c -> ReifiedFold (Either d b) (Either d c)
    right = ReifiedFold b c -> ReifiedFold (Either d b) (Either d c)
    forall (p :: * -> * -> *) a b c.
    Choice p =>
    p a b -> p (Either c a) (Either c b)
    right'
      {-# INLINE right #-}

    instance ArrowApply ReifiedFold where
      app :: ReifiedFold (ReifiedFold b c, b) c
    app = Fold (ReifiedFold b c, b) c -> ReifiedFold (ReifiedFold b c, b) c
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold (ReifiedFold b c, b) c -> ReifiedFold (ReifiedFold b c, b) c)
    -> Fold (ReifiedFold b c, b) c
    -> ReifiedFold (ReifiedFold b c, b) c
    forall a b. (a -> b) -> a -> b
    $ ((ReifiedFold b c, b) -> [c])
    -> (c -> f c) -> (ReifiedFold b c, b) -> f (ReifiedFold b c, b)
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding (((ReifiedFold b c, b) -> [c])
     -> (c -> f c) -> (ReifiedFold b c, b) -> f (ReifiedFold b c, b))
    -> ((ReifiedFold b c, b) -> [c])
    -> (c -> f c)
    -> (ReifiedFold b c, b)
    -> f (ReifiedFold b c, b)
    forall a b. (a -> b) -> a -> b
    $ \(Fold bc :: Fold b c
    bc, b :: b
    b) -> Getting (Endo [c]) b c -> b -> [c]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [c]) b c
    Fold b c
    bc b
    b
      {-# INLINE app #-}

    instance Functor (ReifiedFold s) where
      fmap :: (a -> b) -> ReifiedFold s a -> ReifiedFold s b
    fmap f :: a -> b
    f l :: ReifiedFold s a
    l = Fold s b -> ReifiedFold s b
    forall s a. Fold s a -> ReifiedFold s a
    Fold (ReifiedFold s a
    -> forall (f :: * -> *).
       (Contravariant f, Applicative f) =>
       (a -> f a) -> s -> f s
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold s a
    l((a -> f a) -> s -> f s)
    -> ((b -> f b) -> a -> f a) -> (b -> f b) -> s -> f s
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    .(a -> b) -> (b -> f b) -> a -> f a
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f)
      {-# INLINE fmap #-}

    instance Apply (ReifiedFold s) where
      Fold mf :: Fold s (a -> b)
    mf <.> :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b
    <.> Fold ma :: Fold s a
    ma = Fold s b -> ReifiedFold s b
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s b -> ReifiedFold s b) -> Fold s b -> ReifiedFold s b
    forall a b. (a -> b) -> a -> b
    $ (s -> [b]) -> (b -> f b) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [b]) -> (b -> f b) -> s -> f s)
    -> (s -> [b]) -> (b -> f b) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a -> b]) s (a -> b) -> s -> [a -> b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a -> b]) s (a -> b)
    Fold s (a -> b)
    mf s
    s [a -> b] -> [a] -> [b]
    forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
    <.> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    ma s
    s
      {-# INLINE (<.>) #-}
      Fold mf :: Fold s a
    mf <. :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a
    <. Fold ma :: Fold s b
    ma = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s a -> ReifiedFold s a) -> Fold s a -> ReifiedFold s a
    forall a b. (a -> b) -> a -> b
    $ (s -> [a]) -> (a -> f a) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [a]) -> (a -> f a) -> s -> f s)
    -> (s -> [a]) -> (a -> f a) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    mf s
    s [a] -> [b] -> [a]
    forall (f :: * -> *) a b. Apply f => f a -> f b -> f a
    <. Getting (Endo [b]) s b -> s -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [b]) s b
    Fold s b
    ma s
    s
      {-# INLINE (<.) #-}
      Fold mf :: Fold s a
    mf .> :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b
    .> Fold ma :: Fold s b
    ma = Fold s b -> ReifiedFold s b
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s b -> ReifiedFold s b) -> Fold s b -> ReifiedFold s b
    forall a b. (a -> b) -> a -> b
    $ (s -> [b]) -> (b -> f b) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [b]) -> (b -> f b) -> s -> f s)
    -> (s -> [b]) -> (b -> f b) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    mf s
    s [a] -> [b] -> [b]
    forall (f :: * -> *) a b. Apply f => f a -> f b -> f b
    .> Getting (Endo [b]) s b -> s -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [b]) s b
    Fold s b
    ma s
    s
      {-# INLINE (.>) #-}

    instance Applicative (ReifiedFold s) where
      pure :: a -> ReifiedFold s a
    pure a :: a
    a = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s a -> ReifiedFold s a) -> Fold s a -> ReifiedFold s a
    forall a b. (a -> b) -> a -> b
    $ (s -> [a]) -> (a -> f a) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [a]) -> (a -> f a) -> s -> f s)
    -> (s -> [a]) -> (a -> f a) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \_ -> [a
    a]
      {-# INLINE pure #-}
      Fold mf :: Fold s (a -> b)
    mf <*> :: ReifiedFold s (a -> b) -> ReifiedFold s a -> ReifiedFold s b
    <*> Fold ma :: Fold s a
    ma = Fold s b -> ReifiedFold s b
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s b -> ReifiedFold s b) -> Fold s b -> ReifiedFold s b
    forall a b. (a -> b) -> a -> b
    $ (s -> [b]) -> (b -> f b) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [b]) -> (b -> f b) -> s -> f s)
    -> (s -> [b]) -> (b -> f b) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a -> b]) s (a -> b) -> s -> [a -> b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a -> b]) s (a -> b)
    Fold s (a -> b)
    mf s
    s [a -> b] -> [a] -> [b]
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    ma s
    s
      {-# INLINE (<*>) #-}
      Fold mf :: Fold s a
    mf <* :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s a
    <* Fold ma :: Fold s b
    ma = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s a -> ReifiedFold s a) -> Fold s a -> ReifiedFold s a
    forall a b. (a -> b) -> a -> b
    $ (s -> [a]) -> (a -> f a) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [a]) -> (a -> f a) -> s -> f s)
    -> (s -> [a]) -> (a -> f a) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    mf s
    s [a] -> [b] -> [a]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
    <* Getting (Endo [b]) s b -> s -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [b]) s b
    Fold s b
    ma s
    s
      {-# INLINE (<*) #-}
      Fold mf :: Fold s a
    mf *> :: ReifiedFold s a -> ReifiedFold s b -> ReifiedFold s b
    *> Fold ma :: Fold s b
    ma = Fold s b -> ReifiedFold s b
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s b -> ReifiedFold s b) -> Fold s b -> ReifiedFold s b
    forall a b. (a -> b) -> a -> b
    $ (s -> [b]) -> (b -> f b) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [b]) -> (b -> f b) -> s -> f s)
    -> (s -> [b]) -> (b -> f b) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    mf s
    s [a] -> [b] -> [b]
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Getting (Endo [b]) s b -> s -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [b]) s b
    Fold s b
    ma s
    s
      {-# INLINE (*>) #-}

    instance Alternative (ReifiedFold s) where
      empty :: ReifiedFold s a
    empty = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold Fold s a
    forall (f :: * -> *) pafb s. Applicative f => pafb -> s -> f s
    ignored
      {-# INLINE empty #-}
      Fold ma :: Fold s a
    ma <|> :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    <|> Fold mb :: Fold s a
    mb = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s a -> ReifiedFold s a) -> Fold s a -> ReifiedFold s a
    forall a b. (a -> b) -> a -> b
    $ (s -> [a]) -> Fold s a
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding (\s :: s
    s -> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    ma s
    s [a] -> [a] -> [a]
    forall a. [a] -> [a] -> [a]
    ++ Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    mb s
    s)
      {-# INLINE (<|>) #-}

    instance Bind (ReifiedFold s) where
      Fold ma :: Fold s a
    ma >>- :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b
    >>- f :: a -> ReifiedFold s b
    f = Fold s b -> ReifiedFold s b
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s b -> ReifiedFold s b) -> Fold s b -> ReifiedFold s b
    forall a b. (a -> b) -> a -> b
    $ (s -> [b]) -> (b -> f b) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [b]) -> (b -> f b) -> s -> f s)
    -> (s -> [b]) -> (b -> f b) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    ma s
    s [a] -> (a -> [b]) -> [b]
    forall (m :: * -> *) a b. Bind m => m a -> (a -> m b) -> m b
    >>- \a :: a
    a -> Getting (Endo [b]) s b -> s -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf (ReifiedFold s b -> Fold s b
    forall s a. ReifiedFold s a -> Fold s a
    runFold (a -> ReifiedFold s b
    f a
    a)) s
    s
      {-# INLINE (>>-) #-}

    instance Monad (ReifiedFold s) where
      return :: a -> ReifiedFold s a
    return = a -> ReifiedFold s a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
      {-# INLINE return #-}
      Fold ma :: Fold s a
    ma >>= :: ReifiedFold s a -> (a -> ReifiedFold s b) -> ReifiedFold s b
    >>= f :: a -> ReifiedFold s b
    f = Fold s b -> ReifiedFold s b
    forall s a. Fold s a -> ReifiedFold s a
    Fold (Fold s b -> ReifiedFold s b) -> Fold s b -> ReifiedFold s b
    forall a b. (a -> b) -> a -> b
    $ (s -> [b]) -> (b -> f b) -> s -> f s
    forall (f :: * -> *) s a. Foldable f => (s -> f a) -> Fold s a
    folding ((s -> [b]) -> (b -> f b) -> s -> f s)
    -> (s -> [b]) -> (b -> f b) -> s -> f s
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> Getting (Endo [a]) s a -> s -> [a]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf Getting (Endo [a]) s a
    Fold s a
    ma s
    s [a] -> (a -> [b]) -> [b]
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a :: a
    a -> Getting (Endo [b]) s b -> s -> [b]
    forall a s. Getting (Endo [a]) s a -> s -> [a]
    toListOf (ReifiedFold s b -> Fold s b
    forall s a. ReifiedFold s a -> Fold s a
    runFold (a -> ReifiedFold s b
    f a
    a)) s
    s
      {-# INLINE (>>=) #-}

    instance MonadPlus (ReifiedFold s) where
      mzero :: ReifiedFold s a
    mzero = ReifiedFold s a
    forall (f :: * -> *) a. Alternative f => f a
    empty
      {-# INLINE mzero #-}
      mplus :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    mplus = ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    (<|>)
      {-# INLINE mplus #-}

    instance MonadReader s (ReifiedFold s) where
      ask :: ReifiedFold s s
    ask = Fold s s -> ReifiedFold s s
    forall s a. Fold s a -> ReifiedFold s a
    Fold forall a. a -> a
    Fold s s
    id
      {-# INLINE ask #-}
      local :: (s -> s) -> ReifiedFold s a -> ReifiedFold s a
    local f :: s -> s
    f m :: ReifiedFold s a
    m = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold ((s -> s) -> Optic' (->) f s s
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to s -> s
    f Optic' (->) f s s
    -> ((a -> f a) -> s -> f s) -> (a -> f a) -> s -> f s
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedFold s a -> Fold s a
    forall s a. ReifiedFold s a -> Fold s a
    runFold ReifiedFold s a
    m)
      {-# INLINE local #-}

    instance Semigroup (ReifiedFold s a) where
      <> :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    (<>) = ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    (<|>)
      {-# INLINE (<>) #-}

    instance Monoid (ReifiedFold s a) where
      mempty :: ReifiedFold s a
    mempty = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold Fold s a
    forall (f :: * -> *) pafb s. Applicative f => pafb -> s -> f s
    ignored
      {-# INLINE mempty #-}
      mappend :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    mappend = ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    (<|>)
      {-# INLINE mappend #-}

    instance Alt (ReifiedFold s) where
      <!> :: ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    (<!>) = ReifiedFold s a -> ReifiedFold s a -> ReifiedFold s a
    forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
    (<|>)
      {-# INLINE (<!>) #-}

    instance Plus (ReifiedFold s) where
      zero :: ReifiedFold s a
    zero = Fold s a -> ReifiedFold s a
    forall s a. Fold s a -> ReifiedFold s a
    Fold Fold s a
    forall (f :: * -> *) pafb s. Applicative f => pafb -> s -> f s
    ignored
      {-# INLINE zero #-}

    ------------------------------------------------------------------------------
    -- IndexedFold
    ------------------------------------------------------------------------------

    newtype ReifiedIndexedFold i s a = IndexedFold { ReifiedIndexedFold i s a
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Applicative f) =>
       p a (f a) -> s -> f s
    runIndexedFold :: IndexedFold i s a }

    instance Semigroup (ReifiedIndexedFold i s a) where
      <> :: ReifiedIndexedFold i s a
    -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a
    (<>) = ReifiedIndexedFold i s a
    -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a
    forall (f :: * -> *) a. Alt f => f a -> f a -> f a
    (<!>)
      {-# INLINE (<>) #-}

    instance Monoid (ReifiedIndexedFold i s a) where
      mempty :: ReifiedIndexedFold i s a
    mempty = IndexedFold i s a -> ReifiedIndexedFold i s a
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold forall (f :: * -> *) pafb s. Applicative f => pafb -> s -> f s
    IndexedFold i s a
    ignored
      {-# INLINE mempty #-}
      mappend :: ReifiedIndexedFold i s a
    -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a
    mappend = ReifiedIndexedFold i s a
    -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a
    forall (f :: * -> *) a. Alt f => f a -> f a -> f a
    (<!>)
      {-# INLINE mappend #-}

    instance Alt (ReifiedIndexedFold i s) where
      IndexedFold ma :: IndexedFold i s a
    ma <!> :: ReifiedIndexedFold i s a
    -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s a
    <!> IndexedFold mb :: IndexedFold i s a
    mb = IndexedFold i s a -> ReifiedIndexedFold i s a
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold (IndexedFold i s a -> ReifiedIndexedFold i s a)
    -> IndexedFold i s a -> ReifiedIndexedFold i s a
    forall a b. (a -> b) -> a -> b
    $
        (s -> [(i, a)]) -> Over p f s s a a
    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 -> [(i, a)]) -> Over p f s s a a)
    -> (s -> [(i, a)]) -> Over p f s s a a
    forall a b. (a -> b) -> a -> b
    $ \s :: s
    s -> IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
    forall i a s. IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
    itoListOf IndexedGetting i (Endo [(i, a)]) s a
    IndexedFold i s a
    ma s
    s [(i, a)] -> [(i, a)] -> [(i, a)]
    forall a. [a] -> [a] -> [a]
    ++ IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
    forall i a s. IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
    itoListOf IndexedGetting i (Endo [(i, a)]) s a
    IndexedFold i s a
    mb s
    s
      {-# INLINE (<!>) #-}

    instance Plus (ReifiedIndexedFold i s) where
      zero :: ReifiedIndexedFold i s a
    zero = IndexedFold i s a -> ReifiedIndexedFold i s a
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold forall (f :: * -> *) pafb s. Applicative f => pafb -> s -> f s
    IndexedFold i s a
    ignored
      {-# INLINE zero #-}

    instance Functor (ReifiedIndexedFold i s) where
      fmap :: (a -> b) -> ReifiedIndexedFold i s a -> ReifiedIndexedFold i s b
    fmap f :: a -> b
    f l :: ReifiedIndexedFold i s a
    l = IndexedFold i s b -> ReifiedIndexedFold i s b
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold (ReifiedIndexedFold i s a
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Applicative f) =>
       p a (f a) -> s -> f s
    forall i s a. ReifiedIndexedFold i s a -> IndexedFold i s a
    runIndexedFold ReifiedIndexedFold i s a
    l (p a (f a) -> s -> f s)
    -> (p b (f b) -> p a (f a)) -> p b (f b) -> s -> f s
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> b) -> p b (f b) -> p a (f a)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f)
      {-# INLINE fmap #-}

    instance Profunctor (ReifiedIndexedFold i) where
      dimap :: (a -> b)
    -> (c -> d) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a d
    dimap f :: a -> b
    f g :: c -> d
    g l :: ReifiedIndexedFold i b c
    l = IndexedFold i a d -> ReifiedIndexedFold i a d
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold ((a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f Optic' (->) f a b
    -> (p d (f d) -> b -> f b) -> p d (f d) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedIndexedFold i b c
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Applicative f) =>
       p c (f c) -> b -> f b
    forall i s a. ReifiedIndexedFold i s a -> IndexedFold i s a
    runIndexedFold ReifiedIndexedFold i b c
    l (p c (f c) -> b -> f b)
    -> (p d (f d) -> p c (f c)) -> p d (f d) -> b -> f b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (c -> d) -> p d (f d) -> p c (f c)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to c -> d
    g)
      {-# INLINE dimap #-}
      lmap :: (a -> b) -> ReifiedIndexedFold i b c -> ReifiedIndexedFold i a c
    lmap f :: a -> b
    f l :: ReifiedIndexedFold i b c
    l = IndexedFold i a c -> ReifiedIndexedFold i a c
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold ((a -> b) -> Optic' (->) f a b
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to a -> b
    f Optic' (->) f a b
    -> (p c (f c) -> b -> f b) -> p c (f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ReifiedIndexedFold i b c
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Applicative f) =>
       p c (f c) -> b -> f b
    forall i s a. ReifiedIndexedFold i s a -> IndexedFold i s a
    runIndexedFold ReifiedIndexedFold i b c
    l)
      {-# INLINE lmap #-}
      rmap :: (b -> c) -> ReifiedIndexedFold i a b -> ReifiedIndexedFold i a c
    rmap g :: b -> c
    g l :: ReifiedIndexedFold i a b
    l = IndexedFold i a c -> ReifiedIndexedFold i a c
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold (ReifiedIndexedFold i a b
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Indexable i p, Contravariant f, Applicative f) =>
       p b (f b) -> a -> f a
    forall i s a. ReifiedIndexedFold i s a -> IndexedFold i s a
    runIndexedFold ReifiedIndexedFold i a b
    l (p b (f b) -> a -> f a)
    -> (p c (f c) -> p b (f b)) -> p c (f c) -> a -> f a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (b -> c) -> p c (f c) -> p b (f b)
    forall (p :: * -> * -> *) (f :: * -> *) s a.
    (Profunctor p, Contravariant f) =>
    (s -> a) -> Optic' p f s a
    to b -> c
    g)
      {-# INLINE rmap #-}

    instance Sieve (ReifiedIndexedFold i) (Compose [] ((,) i)) where
      sieve :: ReifiedIndexedFold i a b -> a -> Compose [] ((,) i) b
    sieve (IndexedFold l :: IndexedFold i a b
    l) = [(i, b)] -> Compose [] ((,) i) b
    forall k k1 (f :: k -> *) (g :: k1 -> k) (a :: k1).
    f (g a) -> Compose f g a
    Compose ([(i, b)] -> Compose [] ((,) i) b)
    -> (a -> [(i, b)]) -> a -> Compose [] ((,) i) b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IndexedGetting i (Endo [(i, b)]) a b -> a -> [(i, b)]
    forall i a s. IndexedGetting i (Endo [(i, a)]) s a -> s -> [(i, a)]
    itoListOf IndexedGetting i (Endo [(i, b)]) a b
    IndexedFold i a b
    l
      {-# INLINE sieve #-}

    instance Representable (ReifiedIndexedFold i) where
      type Rep (ReifiedIndexedFold i) = Compose [] ((,) i)
      tabulate :: (d -> Rep (ReifiedIndexedFold i) c) -> ReifiedIndexedFold i d c
    tabulate k :: d -> Rep (ReifiedIndexedFold i) c
    k = IndexedFold i d c -> ReifiedIndexedFold i d c
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold (IndexedFold i d c -> ReifiedIndexedFold i d c)
    -> IndexedFold i d c -> ReifiedIndexedFold i d c
    forall a b. (a -> b) -> a -> b
    $ \f :: p c (f c)
    f -> f () -> f d
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f () -> f d) -> (d -> f ()) -> d -> f d
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((i, c) -> f Any) -> [(i, c)] -> f ()
    forall (t :: * -> *) (f :: * -> *) a b.
    (Foldable t, Applicative f) =>
    (a -> f b) -> t a -> f ()
    traverse_ (f c -> f Any
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f c -> f Any) -> ((i, c) -> f c) -> (i, c) -> f Any
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (i -> c -> f c) -> (i, c) -> f c
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry (p c (f c) -> i -> c -> f c
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p c (f c)
    f)) ([(i, c)] -> f ()) -> (d -> [(i, c)]) -> d -> f ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Compose [] ((,) i) c -> [(i, c)]
    forall k1 (f :: k1 -> *) k2 (g :: k2 -> k1) (a :: k2).
    Compose f g a -> f (g a)
    getCompose (Compose [] ((,) i) c -> [(i, c)])
    -> (d -> Compose [] ((,) i) c) -> d -> [(i, c)]
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . d -> Compose [] ((,) i) c
    d -> Rep (ReifiedIndexedFold i) c
    k
      {-# INLINE tabulate #-}

    instance Strong (ReifiedIndexedFold i) where
      first' :: ReifiedIndexedFold i a b -> ReifiedIndexedFold i (a, c) (b, c)
    first' l :: ReifiedIndexedFold i a b
    l  = IndexedFold i (a, c) (b, c) -> ReifiedIndexedFold i (a, c) (b, c)
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold (IndexedFold i (a, c) (b, c) -> ReifiedIndexedFold i (a, c) (b, c))
    -> IndexedFold i (a, c) (b, c)
    -> ReifiedIndexedFold i (a, c) (b, c)
    forall a b. (a -> b) -> a -> b
    $ \f :: p (b, c) (f (b, c))
    f (s,c) ->
        f a -> f (a, c)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (a, c)) -> f a -> f (a, c)
    forall a b. (a -> b) -> a -> b
    $ ReifiedIndexedFold i a b -> p b (f b) -> a -> f a
    forall i s a. ReifiedIndexedFold i s a -> IndexedFold i s a
    runIndexedFold ReifiedIndexedFold i a b
    l ((b -> (b, c))
    -> (f (b, c) -> f b) -> p (b, c) (f (b, c)) -> p b (f b)
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((b -> c -> (b, c)) -> c -> b -> (b, c)
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip (,) c
    c) f (b, c) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom p (b, c) (f (b, c))
    f) a
    s
      {-# INLINE first' #-}
      second' :: ReifiedIndexedFold i a b -> ReifiedIndexedFold i (c, a) (c, b)
    second' l :: ReifiedIndexedFold i a b
    l = IndexedFold i (c, a) (c, b) -> ReifiedIndexedFold i (c, a) (c, b)
    forall i s a. IndexedFold i s a -> ReifiedIndexedFold i s a
    IndexedFold (IndexedFold i (c, a) (c, b) -> ReifiedIndexedFold i (c, a) (c, b))
    -> IndexedFold i (c, a) (c, b)
    -> ReifiedIndexedFold i (c, a) (c, b)
    forall a b. (a -> b) -> a -> b
    $ \f :: p (c, b) (f (c, b))
    f (c,s) ->
        f a -> f (c, a)
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (f a -> f (c, a)) -> f a -> f (c, a)
    forall a b. (a -> b) -> a -> b
    $ ReifiedIndexedFold i a b -> p b (f b) -> a -> f a
    forall i s a. ReifiedIndexedFold i s a -> IndexedFold i s a
    runIndexedFold ReifiedIndexedFold i a b
    l ((b -> (c, b))
    -> (f (c, b) -> f b) -> p (c, b) (f (c, b)) -> p b (f b)
    forall (p :: * -> * -> *) a b c d.
    Profunctor p =>
    (a -> b) -> (c -> d) -> p b c -> p a d
    dimap ((,) c
    c) f (c, b) -> f b
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom p (c, b) (f (c, b))
    f) a
    s
      {-# INLINE second' #-}

    ------------------------------------------------------------------------------
    -- Setter
    ------------------------------------------------------------------------------

    -- | Reify a 'Setter' so it can be stored safely in a container.
    newtype ReifiedSetter s t a b = Setter { ReifiedSetter s t a b
    -> forall (f :: * -> *). Settable f => (a -> f b) -> s -> f t
    runSetter :: Setter s t a b }

    -- | @
    -- type 'ReifiedSetter'' = 'Simple' 'ReifiedSetter'
    -- @
    type ReifiedSetter' s a = ReifiedSetter s s a a

    ------------------------------------------------------------------------------
    -- IndexedSetter
    ------------------------------------------------------------------------------

    -- | Reify an 'IndexedSetter' so it can be stored safely in a container.
    newtype ReifiedIndexedSetter i s t a b =
      IndexedSetter { ReifiedIndexedSetter i s t a b
    -> forall (f :: * -> *) (p :: * -> * -> *).
       (Indexable i p, Settable f) =>
       p a (f b) -> s -> f t
    runIndexedSetter :: IndexedSetter i s t a b }

    -- | @
    -- type 'ReifiedIndexedSetter'' i = 'Simple' ('ReifiedIndexedSetter' i)
    -- @
    type ReifiedIndexedSetter' i s a = ReifiedIndexedSetter i s s a a

    ------------------------------------------------------------------------------
    -- Iso
    ------------------------------------------------------------------------------

    -- | Reify an 'Iso' so it can be stored safely in a container.
    newtype ReifiedIso s t a b = Iso { ReifiedIso s t a b
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Profunctor p, Functor f) =>
       p a (f b) -> p s (f t)
    runIso :: Iso s t a b }

    -- | @
    -- type 'ReifiedIso'' = 'Simple' 'ReifiedIso'
    -- @
    type ReifiedIso' s a = ReifiedIso s s a a

    ------------------------------------------------------------------------------
    -- Prism
    ------------------------------------------------------------------------------

    -- | Reify a 'Prism' so it can be stored safely in a container.
    newtype ReifiedPrism s t a b = Prism { ReifiedPrism s t a b
    -> forall (p :: * -> * -> *) (f :: * -> *).
       (Choice p, Applicative f) =>
       p a (f b) -> p s (f t)
    runPrism :: Prism s t a b }

    -- | @
    -- type 'ReifiedPrism'' = 'Simple' 'ReifiedPrism'
    -- @
    type ReifiedPrism' s a = ReifiedPrism s s a a