    {-# LANGUAGE CPP #-}
    {-# LANGUAGE Rank2Types #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE TypeOperators #-}
    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE Trustworthy #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Control.Lens.Internal.Indexed
    -- Copyright   :  (C) 2012-2016 Edward Kmett
    -- License     :  BSD-style (see the file LICENSE)
    -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
    -- Stability   :  experimental
    -- Portability :  non-portable
    --
    -- Internal implementation details for 'Indexed' lens-likes
    ----------------------------------------------------------------------------
    module Control.Lens.Internal.Indexed
      (
      -- * An Indexed Profunctor
        Indexed(..)
      -- * Classes
      , Conjoined(..)
      , Indexable(..)
      -- * Indexing
      , Indexing(..)
      , indexing
      -- * 64-bit Indexing
      , Indexing64(..)
      , indexing64
      -- * Converting to Folds
      , withIndex
      , asIndex
      ) where

    import Prelude ()

    import Control.Arrow as Arrow
    import qualified Control.Category as C
    import Control.Comonad
    import Control.Lens.Internal.Prelude
    import Control.Lens.Internal.Instances ()
    import Control.Monad.Fix
    import Data.Distributive
    import Data.Functor.Bind
    import Data.Int
    import Data.Profunctor.Closed
    import Data.Profunctor.Rep

    -- $setup
    -- >>> :set -XNoOverloadedStrings
    -- >>> import Control.Lens
    -- >>> import Numeric.Lens
    -- >>> import Data.Semigroup (Semigroup (..))
    --
    ------------------------------------------------------------------------------
    -- Conjoined
    ------------------------------------------------------------------------------

    -- | This is a 'Profunctor' that is both 'Corepresentable' by @f@ and 'Representable' by @g@ such
    -- that @f@ is left adjoint to @g@. From this you can derive a lot of structure due
    -- to the preservation of limits and colimits.
    class
      ( Choice p, Corepresentable p, Comonad (Corep p), Traversable (Corep p)
      , Strong p, Representable p, Monad (Rep p), MonadFix (Rep p), Distributive (Rep p)
      , Costrong p, ArrowLoop p, ArrowApply p, ArrowChoice p, Closed p
      ) => Conjoined p where

      -- | 'Conjoined' is strong enough to let us distribute every 'Conjoined'
      -- 'Profunctor' over every Haskell 'Functor'. This is effectively a
      -- generalization of 'fmap'.
      distrib :: Functor f => p a b -> p (f a) (f b)
      distrib = (f a -> Rep p (f b)) -> p (f a) (f b)
    forall d c. (d -> Rep p c) -> p d c
    forall (p :: * -> * -> *) d c.
    Representable p =>
    (d -> Rep p c) -> p d c
    tabulate ((f a -> Rep p (f b)) -> p (f a) (f b))
    -> (p a b -> f a -> Rep p (f b)) -> p a b -> p (f a) (f b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (a -> Rep p b) -> f a -> Rep p (f b)
    forall (g :: * -> *) (f :: * -> *) a b.
    (Distributive g, Functor f) =>
    (a -> g b) -> f a -> g (f b)
    forall (f :: * -> *) a b.
    Functor f =>
    (a -> Rep p b) -> f a -> Rep p (f b)
    collect ((a -> Rep p b) -> f a -> Rep p (f b))
    -> (p a b -> a -> Rep p b) -> p a b -> f a -> Rep p (f b)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . p a b -> a -> Rep p b
    forall a b. p a b -> a -> Rep p b
    forall (p :: * -> * -> *) (f :: * -> *) a b.
    Sieve p f =>
    p a b -> a -> f b
    sieve
      {-# INLINE distrib #-}

      -- | This permits us to make a decision at an outermost point about whether or not we use an index.
      --
      -- Ideally any use of this function should be done in such a way so that you compute the same answer,
      -- but this cannot be enforced at the type level.
      conjoined :: ((p ~ (->)) => q (a -> b) r) -> q (p a b) r -> q (p a b) r
      conjoined (p ~ (->)) => q (a -> b) r
    _ q (p a b) r
    r = q (p a b) r
    r
      {-# INLINE conjoined #-}

    instance Conjoined (->) where
      distrib :: forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    distrib = (a -> b) -> f a -> f b
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap
      {-# INLINE distrib #-}
      conjoined :: forall (q :: * -> * -> *) a b r.
    (((->) ~ (->)) => q (a -> b) r) -> q (a -> b) r -> q (a -> b) r
    conjoined ((->) ~ (->)) => q (a -> b) r
    l q (a -> b) r
    _ = q (a -> b) r
    ((->) ~ (->)) => q (a -> b) r
    l
      {-# INLINE conjoined #-}

    ----------------------------------------------------------------------------
    -- Indexable
    ----------------------------------------------------------------------------

    -- | This class permits overloading of function application for things that
    -- also admit a notion of a key or index.
    class Conjoined p => Indexable i p where
      -- | Build a function from an 'indexed' function.
      indexed :: p a b -> i -> a -> b

    instance Indexable i (->) where
      indexed :: forall a b. (a -> b) -> i -> a -> b
    indexed = (a -> b) -> i -> a -> b
    forall a b. a -> b -> a
    const
      {-# INLINE indexed #-}

    -----------------------------------------------------------------------------
    -- Indexed Internals
    -----------------------------------------------------------------------------

    -- | A function with access to a index. This constructor may be useful when you need to store
    -- an 'Indexable' in a container to avoid @ImpredicativeTypes@.
    --
    -- @index :: Indexed i a b -> i -> a -> b@
    newtype Indexed i a b = Indexed { forall i a b. Indexed i a b -> i -> a -> b
    runIndexed :: i -> a -> b }

    instance Functor (Indexed i a) where
      fmap :: forall a b. (a -> b) -> Indexed i a a -> Indexed i a b
    fmap a -> b
    g (Indexed i -> a -> a
    f) = (i -> a -> b) -> Indexed i a b
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> b) -> Indexed i a b) -> (i -> a -> b) -> Indexed i a b
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> a -> b
    g (i -> a -> a
    f i
    i a
    a)
      {-# INLINE fmap #-}

    instance Apply (Indexed i a) where
      Indexed i -> a -> a -> b
    f <.> :: forall a b. Indexed i a (a -> b) -> Indexed i a a -> Indexed i a b
    <.> Indexed i -> a -> a
    g = (i -> a -> b) -> Indexed i a b
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> b) -> Indexed i a b) -> (i -> a -> b) -> Indexed i a b
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> i -> a -> a -> b
    f i
    i a
    a (i -> a -> a
    g i
    i a
    a)
      {-# INLINE (<.>) #-}

    instance Applicative (Indexed i a) where
      pure :: forall a. a -> Indexed i a a
    pure a
    b = (i -> a -> a) -> Indexed i a a
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> a) -> Indexed i a a) -> (i -> a -> a) -> Indexed i a a
    forall a b. (a -> b) -> a -> b
    $ \i
    _ a
    _ -> a
    b
      {-# INLINE pure #-}
      Indexed i -> a -> a -> b
    f <*> :: forall a b. Indexed i a (a -> b) -> Indexed i a a -> Indexed i a b
    <*> Indexed i -> a -> a
    g = (i -> a -> b) -> Indexed i a b
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> b) -> Indexed i a b) -> (i -> a -> b) -> Indexed i a b
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> i -> a -> a -> b
    f i
    i a
    a (i -> a -> a
    g i
    i a
    a)
      {-# INLINE (<*>) #-}

    instance Bind (Indexed i a) where
      Indexed i -> a -> a
    f >>- :: forall a b. Indexed i a a -> (a -> Indexed i a b) -> Indexed i a b
    >>- a -> Indexed i a b
    k = (i -> a -> b) -> Indexed i a b
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> b) -> Indexed i a b) -> (i -> a -> b) -> Indexed i a b
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> Indexed i a b -> i -> a -> b
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed (a -> Indexed i a b
    k (i -> a -> a
    f i
    i a
    a)) i
    i a
    a
      {-# INLINE (>>-) #-}

    instance Monad (Indexed i a) where
      return :: forall a. a -> Indexed i a a
    return = a -> Indexed i a a
    forall a. a -> Indexed i a a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
      {-# INLINE return #-}
      Indexed i -> a -> a
    f >>= :: forall a b. Indexed i a a -> (a -> Indexed i a b) -> Indexed i a b
    >>= a -> Indexed i a b
    k = (i -> a -> b) -> Indexed i a b
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> b) -> Indexed i a b) -> (i -> a -> b) -> Indexed i a b
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> Indexed i a b -> i -> a -> b
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed (a -> Indexed i a b
    k (i -> a -> a
    f i
    i a
    a)) i
    i a
    a
      {-# INLINE (>>=) #-}

    instance MonadFix (Indexed i a) where
      mfix :: forall a. (a -> Indexed i a a) -> Indexed i a a
    mfix a -> Indexed i a a
    f = (i -> a -> a) -> Indexed i a a
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> a) -> Indexed i a a) -> (i -> a -> a) -> Indexed i a a
    forall a b. (a -> b) -> a -> b
    $ \ i
    i a
    a -> let o :: a
    o = Indexed i a a -> i -> a -> a
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed (a -> Indexed i a a
    f a
    o) i
    i a
    a in a
    o
      {-# INLINE mfix #-}

    instance Profunctor (Indexed i) where
      dimap :: forall a b c d.
    (a -> b) -> (c -> d) -> Indexed i b c -> Indexed i a d
    dimap a -> b
    ab c -> d
    cd Indexed i b c
    ibc = (i -> a -> d) -> Indexed i a d
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> d) -> Indexed i a d) -> (i -> a -> d) -> Indexed i a d
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> c -> d
    cd (c -> d) -> (a -> c) -> a -> d
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i b c -> i -> b -> c
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i b c
    ibc i
    i (b -> c) -> (a -> b) -> a -> c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    ab
      {-# INLINE dimap #-}
      lmap :: forall a b c. (a -> b) -> Indexed i b c -> Indexed i a c
    lmap a -> b
    ab Indexed i b c
    ibc = (i -> a -> c) -> Indexed i a c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> c) -> Indexed i a c) -> (i -> a -> c) -> Indexed i a c
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> Indexed i b c -> i -> b -> c
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i b c
    ibc i
    i (b -> c) -> (a -> b) -> a -> c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    ab
      {-# INLINE lmap #-}
      rmap :: forall b c a. (b -> c) -> Indexed i a b -> Indexed i a c
    rmap b -> c
    bc Indexed i a b
    iab = (i -> a -> c) -> Indexed i a c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> c) -> Indexed i a c) -> (i -> a -> c) -> Indexed i a c
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> b -> c
    bc (b -> c) -> (a -> b) -> a -> c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i a b -> i -> a -> b
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i a b
    iab i
    i
      {-# INLINE rmap #-}
      .# :: forall a b c (q :: * -> * -> *).
    Coercible b a =>
    Indexed i b c -> q a b -> Indexed i a c
    (.#) Indexed i b c
    ibc q a b
    _ = Indexed i b c -> Indexed i a c
    forall a b. Coercible a b => a -> b
    coerce Indexed i b c
    ibc
      {-# INLINE (.#) #-}
      #. :: forall a b c (q :: * -> * -> *).
    Coercible c b =>
    q b c -> Indexed i a b -> Indexed i a c
    (#.) q b c
    _ = Indexed i a b -> Indexed i a c
    forall a b. Coercible a b => a -> b
    coerce
      {-# INLINE (#.) #-}

    instance Closed (Indexed i) where
      closed :: forall a b x. Indexed i a b -> Indexed i (x -> a) (x -> b)
    closed (Indexed i -> a -> b
    iab) = (i -> (x -> a) -> x -> b) -> Indexed i (x -> a) (x -> b)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> (x -> a) -> x -> b) -> Indexed i (x -> a) (x -> b))
    -> (i -> (x -> a) -> x -> b) -> Indexed i (x -> a) (x -> b)
    forall a b. (a -> b) -> a -> b
    $ \i
    i x -> a
    xa x
    x -> i -> a -> b
    iab i
    i (x -> a
    xa x
    x)

    instance Costrong (Indexed i) where
      unfirst :: forall a d b. Indexed i (a, d) (b, d) -> Indexed i a b
    unfirst (Indexed i -> (a, d) -> (b, d)
    iadbd) = (i -> a -> b) -> Indexed i a b
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> b) -> Indexed i a b) -> (i -> a -> b) -> Indexed i a b
    forall a b. (a -> b) -> a -> b
    $ \i
    i a
    a -> let
          (b
    b, d
    d) = i -> (a, d) -> (b, d)
    iadbd i
    i (a
    a, d
    d)
        in b
    b

    instance Sieve (Indexed i) ((->) i) where
      sieve :: forall a b. Indexed i a b -> a -> i -> b
    sieve = (i -> a -> b) -> a -> i -> b
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip ((i -> a -> b) -> a -> i -> b)
    -> (Indexed i a b -> i -> a -> b) -> Indexed i a b -> a -> i -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i a b -> i -> a -> b
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed
      {-# INLINE sieve #-}

    instance Representable (Indexed i) where
      type Rep (Indexed i) = (->) i
      tabulate :: forall d c. (d -> Rep (Indexed i) c) -> Indexed i d c
    tabulate = (i -> d -> c) -> Indexed i d c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> d -> c) -> Indexed i d c)
    -> ((d -> i -> c) -> i -> d -> c) -> (d -> i -> c) -> Indexed i d c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (d -> i -> c) -> i -> d -> c
    forall a b c. (a -> b -> c) -> b -> a -> c
    flip
      {-# INLINE tabulate #-}

    instance Cosieve (Indexed i) ((,) i) where
      cosieve :: forall a b. Indexed i a b -> (i, a) -> b
    cosieve = (i -> a -> b) -> (i, a) -> b
    forall a b c. (a -> b -> c) -> (a, b) -> c
    uncurry ((i -> a -> b) -> (i, a) -> b)
    -> (Indexed i a b -> i -> a -> b) -> Indexed i a b -> (i, a) -> b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i a b -> i -> a -> b
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed
      {-# INLINE cosieve #-}

    instance Corepresentable (Indexed i) where
      type Corep (Indexed i) = (,) i
      cotabulate :: forall d c. (Corep (Indexed i) d -> c) -> Indexed i d c
    cotabulate = (i -> d -> c) -> Indexed i d c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> d -> c) -> Indexed i d c)
    -> (((i, d) -> c) -> i -> d -> c) -> ((i, d) -> c) -> Indexed i d c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ((i, d) -> c) -> i -> d -> c
    forall a b c. ((a, b) -> c) -> a -> b -> c
    curry
      {-# INLINE cotabulate #-}

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

    instance Strong (Indexed i) where
      second' :: forall a b c. Indexed i a b -> Indexed i (c, a) (c, b)
    second' = Indexed i a b -> Indexed i (c, a) (c, b)
    forall a b c. Indexed i a b -> Indexed i (c, a) (c, b)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    second
      {-# INLINE second' #-}

    instance C.Category (Indexed i) where
      id :: forall a. Indexed i a a
    id = (i -> a -> a) -> Indexed i a a
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((a -> a) -> i -> a -> a
    forall a b. a -> b -> a
    const a -> a
    forall a. a -> a
    id)
      {-# INLINE id #-}
      Indexed i -> b -> c
    f . :: forall b c a. Indexed i b c -> Indexed i a b -> Indexed i a c
    . Indexed i -> a -> b
    g = (i -> a -> c) -> Indexed i a c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> a -> c) -> Indexed i a c) -> (i -> a -> c) -> Indexed i a c
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> i -> b -> c
    f i
    i (b -> c) -> (a -> b) -> a -> c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . i -> a -> b
    g i
    i
      {-# INLINE (.) #-}

    instance Arrow (Indexed i) where
      arr :: forall b c. (b -> c) -> Indexed i b c
    arr b -> c
    f = (i -> b -> c) -> Indexed i b c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed (\i
    _ -> b -> c
    f)
      {-# INLINE arr #-}
      first :: forall b c d. Indexed i b c -> Indexed i (b, d) (c, d)
    first Indexed i b c
    f = (i -> (b, d) -> (c, d)) -> Indexed i (b, d) (c, d)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((b -> c) -> (b, d) -> (c, d)
    forall b c d. (b -> c) -> (b, d) -> (c, d)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (b, d) (c, d)
    Arrow.first ((b -> c) -> (b, d) -> (c, d))
    -> (i -> b -> c) -> i -> (b, d) -> (c, d)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i b c -> i -> b -> c
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i b c
    f)
      {-# INLINE first #-}
      second :: forall b c d. Indexed i b c -> Indexed i (d, b) (d, c)
    second Indexed i b c
    f = (i -> (d, b) -> (d, c)) -> Indexed i (d, b) (d, c)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((b -> c) -> (d, b) -> (d, c)
    forall b c d. (b -> c) -> (d, b) -> (d, c)
    forall (a :: * -> * -> *) b c d.
    Arrow a =>
    a b c -> a (d, b) (d, c)
    Arrow.second ((b -> c) -> (d, b) -> (d, c))
    -> (i -> b -> c) -> i -> (d, b) -> (d, c)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i b c -> i -> b -> c
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i b c
    f)
      {-# INLINE second #-}
      Indexed i -> b -> c
    f *** :: forall b c b' c'.
    Indexed i b c -> Indexed i b' c' -> Indexed i (b, b') (c, c')
    *** Indexed i -> b' -> c'
    g = (i -> (b, b') -> (c, c')) -> Indexed i (b, b') (c, c')
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> (b, b') -> (c, c')) -> Indexed i (b, b') (c, c'))
    -> (i -> (b, b') -> (c, c')) -> Indexed i (b, b') (c, c')
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> i -> b -> c
    f i
    i (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
    forall b c b' c'. (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')
    *** i -> b' -> c'
    g i
    i
      {-# INLINE (***) #-}
      Indexed i -> b -> c
    f &&& :: forall b c c'.
    Indexed i b c -> Indexed i b c' -> Indexed i b (c, c')
    &&& Indexed i -> b -> c'
    g = (i -> b -> (c, c')) -> Indexed i b (c, c')
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> b -> (c, c')) -> Indexed i b (c, c'))
    -> (i -> b -> (c, c')) -> Indexed i b (c, c')
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> i -> b -> c
    f i
    i (b -> c) -> (b -> c') -> b -> (c, c')
    forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
    forall (a :: * -> * -> *) b c c'.
    Arrow a =>
    a b c -> a b c' -> a b (c, c')
    &&& i -> b -> c'
    g i
    i
      {-# INLINE (&&&) #-}

    instance ArrowChoice (Indexed i) where
      left :: forall b c d. Indexed i b c -> Indexed i (Either b d) (Either c d)
    left Indexed i b c
    f = (i -> Either b d -> Either c d)
    -> Indexed i (Either b d) (Either c d)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((b -> c) -> Either b d -> Either c d
    forall b c d. (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)
    -> (i -> b -> c) -> i -> Either b d -> Either c d
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i b c -> i -> b -> c
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i b c
    f)
      {-# INLINE left #-}
      right :: forall b c d. Indexed i b c -> Indexed i (Either d b) (Either d c)
    right Indexed i b c
    f = (i -> Either d b -> Either d c)
    -> Indexed i (Either d b) (Either d c)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((b -> c) -> Either d b -> Either d c
    forall b c d. (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)
    -> (i -> b -> c) -> i -> Either d b -> Either d c
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Indexed i b c -> i -> b -> c
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i b c
    f)
      {-# INLINE right #-}
      Indexed i -> b -> c
    f +++ :: forall b c b' c'.
    Indexed i b c
    -> Indexed i b' c' -> Indexed i (Either b b') (Either c c')
    +++ Indexed i -> b' -> c'
    g = (i -> Either b b' -> Either c c')
    -> Indexed i (Either b b') (Either c c')
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> Either b b' -> Either c c')
     -> Indexed i (Either b b') (Either c c'))
    -> (i -> Either b b' -> Either c c')
    -> Indexed i (Either b b') (Either c c')
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> i -> b -> c
    f i
    i (b -> c) -> (b' -> c') -> Either b b' -> Either c c'
    forall b c b' c'.
    (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')
    +++ i -> b' -> c'
    g i
    i
      {-# INLINE (+++)  #-}
      Indexed i -> b -> d
    f ||| :: forall b d c.
    Indexed i b d -> Indexed i c d -> Indexed i (Either b c) d
    ||| Indexed i -> c -> d
    g = (i -> Either b c -> d) -> Indexed i (Either b c) d
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> Either b c -> d) -> Indexed i (Either b c) d)
    -> (i -> Either b c -> d) -> Indexed i (Either b c) d
    forall a b. (a -> b) -> a -> b
    $ \i
    i -> i -> b -> d
    f i
    i (b -> d) -> (c -> d) -> Either b c -> d
    forall b d c. (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
    ||| i -> c -> d
    g i
    i
      {-# INLINE (|||) #-}

    instance ArrowApply (Indexed i) where
      app :: forall b c. Indexed i (Indexed i b c, b) c
    app = (i -> (Indexed i b c, b) -> c) -> Indexed i (Indexed i b c, b) c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> (Indexed i b c, b) -> c) -> Indexed i (Indexed i b c, b) c)
    -> (i -> (Indexed i b c, b) -> c) -> Indexed i (Indexed i b c, b) c
    forall a b. (a -> b) -> a -> b
    $ \ i
    i (Indexed i b c
    f, b
    b) -> Indexed i b c -> i -> b -> c
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed Indexed i b c
    f i
    i b
    b
      {-# INLINE app #-}

    instance ArrowLoop (Indexed i) where
      loop :: forall b d c. Indexed i (b, d) (c, d) -> Indexed i b c
    loop (Indexed i -> (b, d) -> (c, d)
    f) = (i -> b -> c) -> Indexed i b c
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> b -> c) -> Indexed i b c) -> (i -> b -> c) -> Indexed i b c
    forall a b. (a -> b) -> a -> b
    $ \i
    i b
    b -> let (c
    c,d
    d) = i -> (b, d) -> (c, d)
    f i
    i (b
    b, d
    d) in c
    c
      {-# INLINE loop #-}

    instance Conjoined (Indexed i) where
      distrib :: forall (f :: * -> *) a b.
    Functor f =>
    Indexed i a b -> Indexed i (f a) (f b)
    distrib (Indexed i -> a -> b
    iab) = (i -> f a -> f b) -> Indexed i (f a) (f b)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> f a -> f b) -> Indexed i (f a) (f b))
    -> (i -> f a -> f b) -> Indexed i (f a) (f b)
    forall a b. (a -> b) -> a -> b
    $ \i
    i f a
    fa -> i -> a -> b
    iab i
    i (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> f a
    fa
      {-# INLINE distrib #-}

    instance i ~ j => Indexable i (Indexed j) where
      indexed :: forall a b. Indexed j a b -> i -> a -> b
    indexed = Indexed j a b -> i -> a -> b
    Indexed j a b -> j -> a -> b
    forall i a b. Indexed i a b -> i -> a -> b
    runIndexed
      {-# INLINE indexed #-}

    ------------------------------------------------------------------------------
    -- Indexing
    ------------------------------------------------------------------------------

    -- | 'Applicative' composition of @'Control.Monad.Trans.State.Lazy.State' 'Int'@ with a 'Functor', used
    -- by 'Control.Lens.Indexed.indexed'.
    newtype Indexing f a = Indexing { forall (f :: * -> *) a. Indexing f a -> Int -> (Int, f a)
    runIndexing :: Int -> (Int, f a) }

    instance Functor f => Functor (Indexing f) where
      fmap :: forall a b. (a -> b) -> Indexing f a -> Indexing f b
    fmap a -> b
    f (Indexing Int -> (Int, f a)
    m) = (Int -> (Int, f b)) -> Indexing f b
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing ((Int -> (Int, f b)) -> Indexing f b)
    -> (Int -> (Int, f b)) -> Indexing f b
    forall a b. (a -> b) -> a -> b
    $ \Int
    i -> case Int -> (Int, f a)
    m Int
    i of
        (Int
    j, f a
    x) -> (Int
    j, (a -> b) -> f a -> f b
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> b
    f f a
    x)
      {-# INLINE fmap #-}

    instance Apply f => Apply (Indexing f) where
      Indexing Int -> (Int, f (a -> b))
    mf <.> :: forall a b. Indexing f (a -> b) -> Indexing f a -> Indexing f b
    <.> Indexing Int -> (Int, f a)
    ma = (Int -> (Int, f b)) -> Indexing f b
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing ((Int -> (Int, f b)) -> Indexing f b)
    -> (Int -> (Int, f b)) -> Indexing f b
    forall a b. (a -> b) -> a -> b
    $ \Int
    i -> case Int -> (Int, f (a -> b))
    mf Int
    i of
        (Int
    j, f (a -> b)
    ff) -> case Int -> (Int, f a)
    ma Int
    j of
           ~(Int
    k, f a
    fa) -> (Int
    k, f (a -> b)
    ff f (a -> b) -> f a -> f b
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
    <.> f a
    fa)
      {-# INLINE (<.>) #-}

    instance Applicative f => Applicative (Indexing f) where
      pure :: forall a. a -> Indexing f a
    pure a
    x = (Int -> (Int, f a)) -> Indexing f a
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing ((Int -> (Int, f a)) -> Indexing f a)
    -> (Int -> (Int, f a)) -> Indexing f a
    forall a b. (a -> b) -> a -> b
    $ \Int
    i -> (Int
    i, a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    x)
      {-# INLINE pure #-}
      Indexing Int -> (Int, f (a -> b))
    mf <*> :: forall a b. Indexing f (a -> b) -> Indexing f a -> Indexing f b
    <*> Indexing Int -> (Int, f a)
    ma = (Int -> (Int, f b)) -> Indexing f b
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing ((Int -> (Int, f b)) -> Indexing f b)
    -> (Int -> (Int, f b)) -> Indexing f b
    forall a b. (a -> b) -> a -> b
    $ \Int
    i -> case Int -> (Int, f (a -> b))
    mf Int
    i of
        (Int
    j, f (a -> b)
    ff) -> case Int -> (Int, f a)
    ma Int
    j of
           ~(Int
    k, f a
    fa) -> (Int
    k, f (a -> b)
    ff f (a -> b) -> f a -> f b
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> f a
    fa)
      {-# INLINE (<*>) #-}

    instance Contravariant f => Contravariant (Indexing f) where
      contramap :: forall a' a. (a' -> a) -> Indexing f a -> Indexing f a'
    contramap a' -> a
    f (Indexing Int -> (Int, f a)
    m) = (Int -> (Int, f a')) -> Indexing f a'
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing ((Int -> (Int, f a')) -> Indexing f a')
    -> (Int -> (Int, f a')) -> Indexing f a'
    forall a b. (a -> b) -> a -> b
    $ \Int
    i -> case Int -> (Int, f a)
    m Int
    i of
        (Int
    j, f a
    ff) -> (Int
    j, (a' -> a) -> f a -> f a'
    forall a' a. (a' -> a) -> f a -> f a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    contramap a' -> a
    f f a
    ff)
      {-# INLINE contramap #-}

    instance Semigroup (f a) => Semigroup (Indexing f a) where
        Indexing Int -> (Int, f a)
    mx <> :: Indexing f a -> Indexing f a -> Indexing f a
    <> Indexing Int -> (Int, f a)
    my = (Int -> (Int, f a)) -> Indexing f a
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing ((Int -> (Int, f a)) -> Indexing f a)
    -> (Int -> (Int, f a)) -> Indexing f a
    forall a b. (a -> b) -> a -> b
    $ \Int
    i -> case Int -> (Int, f a)
    mx Int
    i of
          (Int
    j, f a
    x) -> case Int -> (Int, f a)
    my Int
    j of
             ~(Int
    k, f a
    y) -> (Int
    k, f a
    x f a -> f a -> f a
    forall a. Semigroup a => a -> a -> a
    <> f a
    y)
        {-# INLINE (<>) #-}

    -- |
    --
    -- >>> "cat" ^@.. (folded <> folded)
    -- [(0,'c'),(1,'a'),(2,'t'),(0,'c'),(1,'a'),(2,'t')]
    --
    -- >>> "cat" ^@.. indexing (folded <> folded)
    -- [(0,'c'),(1,'a'),(2,'t'),(3,'c'),(4,'a'),(5,'t')]
    instance Monoid (f a) => Monoid (Indexing f a) where
        mempty :: Indexing f a
    mempty = (Int -> (Int, f a)) -> Indexing f a
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing ((Int -> (Int, f a)) -> Indexing f a)
    -> (Int -> (Int, f a)) -> Indexing f a
    forall a b. (a -> b) -> a -> b
    $ \Int
    i -> (Int
    i, f a
    forall a. Monoid a => a
    mempty)
        {-# INLINE mempty #-}

    #if !(MIN_VERSION_base(4,11,0))
        mappend (Indexing mx) (Indexing my) = Indexing $ \i -> case mx i of
          (j, x) -> case my j of
             ~(k, y) -> (k, mappend x y)
        {-# INLINE mappend #-}
    #endif

    -- | Transform a 'Control.Lens.Traversal.Traversal' into an 'Control.Lens.Traversal.IndexedTraversal' or
    -- a 'Control.Lens.Fold.Fold' into an 'Control.Lens.Fold.IndexedFold', etc.
    --
    -- @
    -- 'indexing' :: 'Control.Lens.Type.Traversal' s t a b -> 'Control.Lens.Type.IndexedTraversal' 'Int' s t a b
    -- 'indexing' :: 'Control.Lens.Type.Prism' s t a b     -> 'Control.Lens.Type.IndexedTraversal' 'Int' s t a b
    -- 'indexing' :: 'Control.Lens.Type.Lens' s t a b      -> 'Control.Lens.Type.IndexedLens' 'Int'  s t a b
    -- 'indexing' :: 'Control.Lens.Type.Iso' s t a b       -> 'Control.Lens.Type.IndexedLens' 'Int' s t a b
    -- 'indexing' :: 'Control.Lens.Type.Fold' s a          -> 'Control.Lens.Type.IndexedFold' 'Int' s a
    -- 'indexing' :: 'Control.Lens.Type.Getter' s a        -> 'Control.Lens.Type.IndexedGetter' 'Int' s a
    -- @
    --
    -- @'indexing' :: 'Indexable' 'Int' p => 'Control.Lens.Type.LensLike' ('Indexing' f) s t a b -> 'Control.Lens.Type.Over' p f s t a b@
    indexing :: Indexable Int p => ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
    indexing :: forall (p :: * -> * -> *) a (f :: * -> *) b s t.
    Indexable Int p =>
    ((a -> Indexing f b) -> s -> Indexing f t) -> p a (f b) -> s -> f t
    indexing (a -> Indexing f b) -> s -> Indexing f t
    l p a (f b)
    iafb s
    s = (Int, f t) -> f t
    forall a b. (a, b) -> b
    snd ((Int, f t) -> f t) -> (Int, f t) -> f t
    forall a b. (a -> b) -> a -> b
    $ Indexing f t -> Int -> (Int, f t)
    forall (f :: * -> *) a. Indexing f a -> Int -> (Int, f a)
    runIndexing ((a -> Indexing f b) -> s -> Indexing f t
    l (\a
    a -> (Int -> (Int, f b)) -> Indexing f b
    forall (f :: * -> *) a. (Int -> (Int, f a)) -> Indexing f a
    Indexing (\Int
    i -> Int
    i Int -> (Int, f b) -> (Int, f b)
    forall a b. a -> b -> b
    `seq` (Int
    i Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1, p a (f b) -> Int -> a -> f b
    forall a b. p a b -> Int -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f b)
    iafb Int
    i a
    a))) s
    s) Int
    0
    {-# INLINE indexing #-}

    ------------------------------------------------------------------------------
    -- Indexing64
    ------------------------------------------------------------------------------

    -- | 'Applicative' composition of @'Control.Monad.Trans.State.Lazy.State' 'Int64'@ with a 'Functor', used
    -- by 'Control.Lens.Indexed.indexed64'.
    newtype Indexing64 f a = Indexing64 { forall (f :: * -> *) a. Indexing64 f a -> Int64 -> (Int64, f a)
    runIndexing64 :: Int64 -> (Int64, f a) }

    instance Functor f => Functor (Indexing64 f) where
      fmap :: forall a b. (a -> b) -> Indexing64 f a -> Indexing64 f b
    fmap a -> b
    f (Indexing64 Int64 -> (Int64, f a)
    m) = (Int64 -> (Int64, f b)) -> Indexing64 f b
    forall (f :: * -> *) a. (Int64 -> (Int64, f a)) -> Indexing64 f a
    Indexing64 ((Int64 -> (Int64, f b)) -> Indexing64 f b)
    -> (Int64 -> (Int64, f b)) -> Indexing64 f b
    forall a b. (a -> b) -> a -> b
    $ \Int64
    i -> case Int64 -> (Int64, f a)
    m Int64
    i of
        (Int64
    j, f a
    x) -> (Int64
    j, (a -> b) -> f a -> f b
    forall a b. (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap a -> b
    f f a
    x)
      {-# INLINE fmap #-}

    instance Apply f => Apply (Indexing64 f) where
      Indexing64 Int64 -> (Int64, f (a -> b))
    mf <.> :: forall a b.
    Indexing64 f (a -> b) -> Indexing64 f a -> Indexing64 f b
    <.> Indexing64 Int64 -> (Int64, f a)
    ma = (Int64 -> (Int64, f b)) -> Indexing64 f b
    forall (f :: * -> *) a. (Int64 -> (Int64, f a)) -> Indexing64 f a
    Indexing64 ((Int64 -> (Int64, f b)) -> Indexing64 f b)
    -> (Int64 -> (Int64, f b)) -> Indexing64 f b
    forall a b. (a -> b) -> a -> b
    $ \Int64
    i -> case Int64 -> (Int64, f (a -> b))
    mf Int64
    i of
        (Int64
    j, f (a -> b)
    ff) -> case Int64 -> (Int64, f a)
    ma Int64
    j of
           ~(Int64
    k, f a
    fa) -> (Int64
    k, f (a -> b)
    ff f (a -> b) -> f a -> f b
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
    <.> f a
    fa)
      {-# INLINE (<.>) #-}

    instance Applicative f => Applicative (Indexing64 f) where
      pure :: forall a. a -> Indexing64 f a
    pure a
    x = (Int64 -> (Int64, f a)) -> Indexing64 f a
    forall (f :: * -> *) a. (Int64 -> (Int64, f a)) -> Indexing64 f a
    Indexing64 ((Int64 -> (Int64, f a)) -> Indexing64 f a)
    -> (Int64 -> (Int64, f a)) -> Indexing64 f a
    forall a b. (a -> b) -> a -> b
    $ \Int64
    i -> (Int64
    i, a -> f a
    forall a. a -> f a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    x)
      {-# INLINE pure #-}
      Indexing64 Int64 -> (Int64, f (a -> b))
    mf <*> :: forall a b.
    Indexing64 f (a -> b) -> Indexing64 f a -> Indexing64 f b
    <*> Indexing64 Int64 -> (Int64, f a)
    ma = (Int64 -> (Int64, f b)) -> Indexing64 f b
    forall (f :: * -> *) a. (Int64 -> (Int64, f a)) -> Indexing64 f a
    Indexing64 ((Int64 -> (Int64, f b)) -> Indexing64 f b)
    -> (Int64 -> (Int64, f b)) -> Indexing64 f b
    forall a b. (a -> b) -> a -> b
    $ \Int64
    i -> case Int64 -> (Int64, f (a -> b))
    mf Int64
    i of
        (Int64
    j, f (a -> b)
    ff) -> case Int64 -> (Int64, f a)
    ma Int64
    j of
           ~(Int64
    k, f a
    fa) -> (Int64
    k, f (a -> b)
    ff f (a -> b) -> f a -> f b
    forall a b. f (a -> b) -> f a -> f b
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
    <*> f a
    fa)
      {-# INLINE (<*>) #-}

    instance Contravariant f => Contravariant (Indexing64 f) where
      contramap :: forall a' a. (a' -> a) -> Indexing64 f a -> Indexing64 f a'
    contramap a' -> a
    f (Indexing64 Int64 -> (Int64, f a)
    m) = (Int64 -> (Int64, f a')) -> Indexing64 f a'
    forall (f :: * -> *) a. (Int64 -> (Int64, f a)) -> Indexing64 f a
    Indexing64 ((Int64 -> (Int64, f a')) -> Indexing64 f a')
    -> (Int64 -> (Int64, f a')) -> Indexing64 f a'
    forall a b. (a -> b) -> a -> b
    $ \Int64
    i -> case Int64 -> (Int64, f a)
    m Int64
    i of
        (Int64
    j, f a
    ff) -> (Int64
    j, (a' -> a) -> f a -> f a'
    forall a' a. (a' -> a) -> f a -> f a'
    forall (f :: * -> *) a' a.
    Contravariant f =>
    (a' -> a) -> f a -> f a'
    contramap a' -> a
    f f a
    ff)
      {-# INLINE contramap #-}

    -- | Transform a 'Control.Lens.Traversal.Traversal' into an 'Control.Lens.Traversal.IndexedTraversal' or
    -- a 'Control.Lens.Fold.Fold' into an 'Control.Lens.Fold.IndexedFold', etc.
    --
    -- This combinator is like 'indexing' except that it handles large traversals and folds gracefully.
    --
    -- @
    -- 'indexing64' :: 'Control.Lens.Type.Traversal' s t a b -> 'Control.Lens.Type.IndexedTraversal' 'Int64' s t a b
    -- 'indexing64' :: 'Control.Lens.Type.Prism' s t a b     -> 'Control.Lens.Type.IndexedTraversal' 'Int64' s t a b
    -- 'indexing64' :: 'Control.Lens.Type.Lens' s t a b      -> 'Control.Lens.Type.IndexedLens' 'Int64' s t a b
    -- 'indexing64' :: 'Control.Lens.Type.Iso' s t a b       -> 'Control.Lens.Type.IndexedLens' 'Int64' s t a b
    -- 'indexing64' :: 'Control.Lens.Type.Fold' s a          -> 'Control.Lens.Type.IndexedFold' 'Int64' s a
    -- 'indexing64' :: 'Control.Lens.Type.Getter' s a        -> 'Control.Lens.Type.IndexedGetter' 'Int64' s a
    -- @
    --
    -- @'indexing64' :: 'Indexable' 'Int64' p => 'Control.Lens.Type.LensLike' ('Indexing64' f) s t a b -> 'Control.Lens.Type.Over' p f s t a b@
    indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t
    indexing64 :: forall (p :: * -> * -> *) a (f :: * -> *) b s t.
    Indexable Int64 p =>
    ((a -> Indexing64 f b) -> s -> Indexing64 f t)
    -> p a (f b) -> s -> f t
    indexing64 (a -> Indexing64 f b) -> s -> Indexing64 f t
    l p a (f b)
    iafb s
    s = (Int64, f t) -> f t
    forall a b. (a, b) -> b
    snd ((Int64, f t) -> f t) -> (Int64, f t) -> f t
    forall a b. (a -> b) -> a -> b
    $ Indexing64 f t -> Int64 -> (Int64, f t)
    forall (f :: * -> *) a. Indexing64 f a -> Int64 -> (Int64, f a)
    runIndexing64 ((a -> Indexing64 f b) -> s -> Indexing64 f t
    l (\a
    a -> (Int64 -> (Int64, f b)) -> Indexing64 f b
    forall (f :: * -> *) a. (Int64 -> (Int64, f a)) -> Indexing64 f a
    Indexing64 (\Int64
    i -> Int64
    i Int64 -> (Int64, f b) -> (Int64, f b)
    forall a b. a -> b -> b
    `seq` (Int64
    i Int64 -> Int64 -> Int64
    forall a. Num a => a -> a -> a
    + Int64
    1, p a (f b) -> Int64 -> a -> f b
    forall a b. p a b -> Int64 -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p a (f b)
    iafb Int64
    i a
    a))) s
    s) Int64
    0
    {-# INLINE indexing64 #-}

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

    -- | Fold a container with indices returning both the indices and the values.
    --
    -- The result is only valid to compose in a 'Traversal', if you don't edit the
    -- index as edits to the index have no effect.
    --
    -- >>> [10, 20, 30] ^.. ifolded . withIndex
    -- [(0,10),(1,20),(2,30)]
    --
    -- >>> [10, 20, 30] ^.. ifolded . withIndex . alongside negated (re _Show)
    -- [(0,"10"),(-1,"20"),(-2,"30")]
    --
    withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)
    withIndex :: forall i (p :: * -> * -> *) (f :: * -> *) s j t.
    (Indexable i p, Functor f) =>
    p (i, s) (f (j, t)) -> Indexed i s (f t)
    withIndex p (i, s) (f (j, t))
    f = (i -> s -> f t) -> Indexed i s (f t)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> s -> f t) -> Indexed i s (f t))
    -> (i -> s -> f t) -> Indexed i s (f t)
    forall a b. (a -> b) -> a -> b
    $ \i
    i s
    a -> (j, t) -> t
    forall a b. (a, b) -> b
    snd ((j, t) -> t) -> f (j, t) -> f t
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> p (i, s) (f (j, t)) -> i -> (i, s) -> f (j, t)
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p (i, s) (f (j, t))
    f i
    i (i
    i, s
    a)
    {-# INLINE withIndex #-}

    -- | When composed with an 'IndexedFold' or 'IndexedTraversal' this yields an
    -- ('Indexed') 'Fold' of the indices.
    asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)
    asIndex :: forall i (p :: * -> * -> *) (f :: * -> *) s.
    (Indexable i p, Contravariant f, Functor f) =>
    p i (f i) -> Indexed i s (f s)
    asIndex p i (f i)
    f = (i -> s -> f s) -> Indexed i s (f s)
    forall i a b. (i -> a -> b) -> Indexed i a b
    Indexed ((i -> s -> f s) -> Indexed i s (f s))
    -> (i -> s -> f s) -> Indexed i s (f s)
    forall a b. (a -> b) -> a -> b
    $ \i
    i s
    _ -> f i -> f s
    forall (f :: * -> *) a b.
    (Functor f, Contravariant f) =>
    f a -> f b
    phantom (p i (f i) -> i -> i -> f i
    forall a b. p a b -> i -> a -> b
    forall i (p :: * -> * -> *) a b.
    Indexable i p =>
    p a b -> i -> a -> b
    indexed p i (f i)
    f i
    i i
    i)
    {-# INLINE asIndex #-}