{-# LANGUAGE CPP #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE EmptyDataDecls #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE PolyKinds #-}

#include "lens-common.h"

-------------------------------------------------------------------------------
-- |
-- Module      :  Control.Lens.Tuple
-- 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.Tuple
  (
  -- * Tuples
    Field1(..)
  , Field2(..)
  , Field3(..)
  , Field4(..)
  , Field5(..)
  , Field6(..)
  , Field7(..)
  , Field8(..)
  , Field9(..)
  , Field10(..)
  , Field11(..)
  , Field12(..)
  , Field13(..)
  , Field14(..)
  , Field15(..)
  , Field16(..)
  , Field17(..)
  , Field18(..)
  , Field19(..)
  -- * Strict variations
  , _1', _2', _3', _4', _5', _6', _7', _8', _9'
  , _10', _11', _12', _13', _14', _15', _16'
  , _17', _18', _19'
  ) where

import           Prelude ()
import           Control.Lens.Lens
import           Control.Lens.Internal.Prelude
import           Data.Functor.Product  (Product (..))
import           Data.Kind
import           Data.Strict           (Pair (..))
import           GHC.Generics          ((:*:) (..), Generic (..), K1 (..),
                                        M1 (..), U1 (..))

-- $setup
-- >>> :set -XNoOverloadedStrings
-- >>> import Control.Lens

-- | Provides access to 1st field of a tuple.
class Field1 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 1st field of a tuple (and possibly change its type).
  --
  -- >>> (1,2)^._1
  -- 1
  --
  -- >>> _1 .~ "hello" $ (1,2)
  -- ("hello",2)
  --
  -- >>> (1,2) & _1 .~ "hello"
  -- ("hello",2)
  --
  -- >>> _1 putStrLn ("hello","world")
  -- hello
  -- ((),"world")
  --
  -- This can also be used on larger tuples as well:
  --
  -- >>> (1,2,3,4,5) & _1 +~ 41
  -- (42,2,3,4,5)
  --
  -- @
  -- '_1' :: 'Lens' (a,b) (a',b) a a'
  -- '_1' :: 'Lens' (a,b,c) (a',b,c) a a'
  -- '_1' :: 'Lens' (a,b,c,d) (a',b,c,d) a a'
  -- ...
  -- '_1' :: 'Lens' (a,b,c,d,e,f,g,h,i) (a',b,c,d,e,f,g,h,i) a a'
  -- @
  _1 :: Lens s t a b
  default _1 :: (Generic s, Generic t, GIxed N0 (Rep s) (Rep t) a b)
             => Lens s t a b
  _1 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N0
proxyN0
  {-# INLINE _1 #-}

instance Field1 (Identity a) (Identity b) a b where
  _1 :: Lens (Identity a) (Identity b) a b
_1 a -> f b
f (Identity a
a) = forall a. a -> Identity a
Identity forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f b
f a
a

instance Field1 (Product f g a) (Product f' g a) (f a) (f' a) where
  _1 :: Lens (Product f g a) (Product f' g a) (f a) (f' a)
_1 f a -> f (f' a)
f (Pair f a
a g a
b) = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair g a
b forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a -> f (f' a)
f f a
a

instance Field1 ((f :*: g) p) ((f' :*: g) p) (f p) (f' p) where
  _1 :: Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
_1 f p -> f (f' p)
f (f p
l :*: g p
r) = (forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: g p
r) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f p -> f (f' p)
f f p
l

-- | @since 4.20
instance Field1 (Pair a b) (Pair a' b) a a' where
  _1 :: Lens (Pair a b) (Pair a' b) a a'
_1 a -> f a'
f (a
a :!: b
b) = (forall a b. a -> b -> Pair a b
:!: b
b) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a'
f a
a

-- | @
-- '_1' k ~(a,b) = (\\a' -> (a',b)) 'Data.Functor.<$>' k a
-- @
instance Field1 (a,b) (a',b) a a' where
  _1 :: Lens (a, b) (a', b) a a'
_1 a -> f a'
k ~(a
a,b
b) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b)
  {-# INLINE _1 #-}

instance Field1 (a,b,c) (a',b,c) a a' where
  _1 :: Lens (a, b, c) (a', b, c) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d) (a',b,c,d) a a' where
  _1 :: Lens (a, b, c, d) (a', b, c, d) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e) (a',b,c,d,e) a a' where
  _1 :: Lens (a, b, c, d, e) (a', b, c, d, e) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f) (a',b,c,d,e,f) a a' where
  _1 :: Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g) (a',b,c,d,e,f,g) a a' where
  _1 :: Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h) (a',b,c,d,e,f,g,h) a a' where
  _1 :: Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i) (a',b,c,d,e,f,g,h,i) a a' where
  _1 :: Lens (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j) (a',b,c,d,e,f,g,h,i,j) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a', b, c, d, e, f, g, h, i, j) a a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk) (a',b,c,d,e,f,g,h,i,j,kk) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a', b, c, d, e, f, g, h, i, j, kk)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l) (a',b,c,d,e,f,g,h,i,j,kk,l) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a', b, c, d, e, f, g, h, i, j, kk, l)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a',b,c,d,e,f,g,h,i,j,kk,l,m) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a', b, c, d, e, f, g, h, i, j, kk, l, m)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a',b,c,d,e,f,g,h,i,j,kk,l,m,n) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a', b, c, d, e, f, g, h, i, j, kk, l, m, n)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a',b,c,d,e,f,g,h,i,j,kk,l,m,n,o) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a',b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a',b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a',b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a',b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) a a' where
  _1 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  a
  a'
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = a -> f a'
k a
a forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \a'
a' -> (a'
a',b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _1 #-}

-- | Provides access to the 2nd field of a tuple.
class Field2 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 2nd field of a tuple.
  --
  -- >>> _2 .~ "hello" $ (1,(),3,4)
  -- (1,"hello",3,4)
  --
  -- >>> (1,2,3,4) & _2 *~ 3
  -- (1,6,3,4)
  --
  -- >>> _2 print (1,2)
  -- 2
  -- (1,())
  --
  -- @
  -- 'Control.Lens.Fold.anyOf' '_2' :: (s -> 'Bool') -> (a, s) -> 'Bool'
  -- 'Data.Traversable.traverse' '.' '_2' :: ('Control.Applicative.Applicative' f, 'Data.Traversable.Traversable' t) => (a -> f b) -> t (s, a) -> f (t (s, b))
  -- 'Control.Lens.Fold.foldMapOf' ('Data.Traversable.traverse' '.' '_2') :: ('Data.Traversable.Traversable' t, 'Data.Monoid.Monoid' m) => (s -> m) -> t (b, s) -> m
  -- @
  _2 :: Lens s t a b
  default _2 :: (Generic s, Generic t, GIxed N1 (Rep s) (Rep t) a b)
             => Lens s t a b
  _2 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N1
proxyN1
  {-# INLINE _2 #-}

instance Field2 (Product f g a) (Product f g' a) (g a) (g' a) where
  _2 :: Lens (Product f g a) (Product f g' a) (g a) (g' a)
_2 g a -> f (g' a)
f (Pair f a
a g a
b) = forall {k} (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair f a
a forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> g a -> f (g' a)
f g a
b

instance Field2 ((f :*: g) p) ((f :*: g') p) (g p) (g' p) where
  _2 :: Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
_2 g p -> f (g' p)
f (f p
l :*: g p
r) = (f p
l forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> g p -> f (g' p)
f g p
r

-- | @since 4.20
instance Field2 (Pair a b) (Pair a b') b b' where
  _2 :: Lens (Pair a b) (Pair a b') b b'
_2 b -> f b'
f (a
a :!: b
b) = (a
a forall a b. a -> b -> Pair a b
:!:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> f b'
f b
b

-- | @
-- '_2' k ~(a,b) = (\\b' -> (a,b')) 'Data.Functor.<$>' k b
-- @
instance Field2 (a,b) (a,b') b b' where
  _2 :: Lens (a, b) (a, b') b b'
_2 b -> f b'
k ~(a
a,b
b) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b')
  {-# INLINE _2 #-}

instance Field2 (a,b,c) (a,b',c) b b' where
  _2 :: Lens (a, b, c) (a, b', c) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d) (a,b',c,d) b b' where
  _2 :: Lens (a, b, c, d) (a, b', c, d) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e) (a,b',c,d,e) b b' where
  _2 :: Lens (a, b, c, d, e) (a, b', c, d, e) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f) (a,b',c,d,e,f) b b' where
  _2 :: Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g) (a,b',c,d,e,f,g) b b' where
  _2 :: Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h) (a,b',c,d,e,f,g,h) b b' where
  _2 :: Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i) (a,b',c,d,e,f,g,h,i) b b' where
  _2 :: Lens (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j) (a,b',c,d,e,f,g,h,i,j) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b', c, d, e, f, g, h, i, j) b b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk) (a,b',c,d,e,f,g,h,i,j,kk) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b', c, d, e, f, g, h, i, j, kk)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b',c,d,e,f,g,h,i,j,kk,l) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b', c, d, e, f, g, h, i, j, kk, l)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b',c,d,e,f,g,h,i,j,kk,l,m) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b', c, d, e, f, g, h, i, j, kk, l, m)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b',c,d,e,f,g,h,i,j,kk,l,m,n) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b', c, d, e, f, g, h, i, j, kk, l, m, n)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b',c,d,e,f,g,h,i,j,kk,l,m,n,o) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b',c,d,e,f,g,h,i,j,kk,l,m,n,o,p) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b',c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b',c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b',c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) b b' where
  _2 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  b
  b'
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = b -> f b'
k b
b forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \b'
b' -> (a
a,b'
b',c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _2 #-}


-- | Provides access to the 3rd field of a tuple.
class Field3 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 3rd field of a tuple.
  _3 :: Lens s t a b
  default _3 :: (Generic s, Generic t, GIxed N2 (Rep s) (Rep t) a b)
             => Lens s t a b
  _3 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N2
proxyN2
  {-# INLINE _3 #-}

instance Field3 (a,b,c) (a,b,c') c c' where
  _3 :: Lens (a, b, c) (a, b, c') c c'
_3 c -> f c'
k ~(a
a,b
b,c
c) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c')
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d) (a,b,c',d) c c' where
  _3 :: Lens (a, b, c, d) (a, b, c', d) c c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e) (a,b,c',d,e) c c' where
  _3 :: Lens (a, b, c, d, e) (a, b, c', d, e) c c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f) (a,b,c',d,e,f) c c' where
  _3 :: Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g) (a,b,c',d,e,f,g) c c' where
  _3 :: Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h) (a,b,c',d,e,f,g,h) c c' where
  _3 :: Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i) (a,b,c',d,e,f,g,h,i) c c' where
  _3 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j) (a,b,c',d,e,f,g,h,i,j) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c', d, e, f, g, h, i, j) c c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c',d,e,f,g,h,i,j,kk) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c', d, e, f, g, h, i, j, kk)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c',d,e,f,g,h,i,j,kk,l) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c', d, e, f, g, h, i, j, kk, l)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c',d,e,f,g,h,i,j,kk,l,m) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c', d, e, f, g, h, i, j, kk, l, m)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c',d,e,f,g,h,i,j,kk,l,m,n) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c', d, e, f, g, h, i, j, kk, l, m, n)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c',d,e,f,g,h,i,j,kk,l,m,n,o) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c',d,e,f,g,h,i,j,kk,l,m,n,o,p) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c',d,e,f,g,h,i,j,kk,l,m,n,o,p,q) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c',d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c',d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) c c' where
  _3 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  c
  c'
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = c -> f c'
k c
c forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \c'
c' -> (a
a,b
b,c'
c',d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _3 #-}

-- | Provide access to the 4th field of a tuple.
class Field4 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 4th field of a tuple.
  _4 :: Lens s t a b
  default _4 :: (Generic s, Generic t, GIxed N3 (Rep s) (Rep t) a b)
             => Lens s t a b
  _4 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N3
proxyN3
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d) (a,b,c,d') d d' where
  _4 :: Lens (a, b, c, d) (a, b, c, d') d d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d')
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e) (a,b,c,d',e) d d' where
  _4 :: Lens (a, b, c, d, e) (a, b, c, d', e) d d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f) (a,b,c,d',e,f) d d' where
  _4 :: Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g) (a,b,c,d',e,f,g) d d' where
  _4 :: Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h) (a,b,c,d',e,f,g,h) d d' where
  _4 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i) (a,b,c,d',e,f,g,h,i) d d' where
  _4 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j) (a,b,c,d',e,f,g,h,i,j) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c, d', e, f, g, h, i, j) d d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d',e,f,g,h,i,j,kk) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d', e, f, g, h, i, j, kk)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d',e,f,g,h,i,j,kk,l) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d', e, f, g, h, i, j, kk, l)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d',e,f,g,h,i,j,kk,l,m) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d', e, f, g, h, i, j, kk, l, m)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d',e,f,g,h,i,j,kk,l,m,n) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d', e, f, g, h, i, j, kk, l, m, n)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d',e,f,g,h,i,j,kk,l,m,n,o) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d',e,f,g,h,i,j,kk,l,m,n,o,p) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d',e,f,g,h,i,j,kk,l,m,n,o,p,q) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d',e,f,g,h,i,j,kk,l,m,n,o,p,q,r) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d',e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) d d' where
  _4 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  d
  d'
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = d -> f d'
k d
d forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \d'
d' -> (a
a,b
b,c
c,d'
d',e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _4 #-}

-- | Provides access to the 5th field of a tuple.
class Field5 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 5th field of a tuple.
  _5 :: Lens s t a b
  default _5 :: (Generic s, Generic t, GIxed N4 (Rep s) (Rep t) a b)
             => Lens s t a b
  _5 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N4
proxyN4
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e) (a,b,c,d,e') e e' where
  _5 :: Lens (a, b, c, d, e) (a, b, c, d, e') e e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e')
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f) (a,b,c,d,e',f) e e' where
  _5 :: Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g) (a,b,c,d,e',f,g) e e' where
  _5 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h) (a,b,c,d,e',f,g,h) e e' where
  _5 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e',f,g,h,i) e e' where
  _5 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j) (a,b,c,d,e',f,g,h,i,j) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e', f, g, h, i, j) e e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d,e',f,g,h,i,j,kk) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d, e', f, g, h, i, j, kk)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e',f,g,h,i,j,kk,l) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e', f, g, h, i, j, kk, l)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e',f,g,h,i,j,kk,l,m) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e', f, g, h, i, j, kk, l, m)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e',f,g,h,i,j,kk,l,m,n) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e', f, g, h, i, j, kk, l, m, n)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e',f,g,h,i,j,kk,l,m,n,o) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e',f,g,h,i,j,kk,l,m,n,o,p) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e',f,g,h,i,j,kk,l,m,n,o,p,q) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e',f,g,h,i,j,kk,l,m,n,o,p,q,r) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e',f,g,h,i,j,kk,l,m,n,o,p,q,r,s) e e' where
  _5 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  e
  e'
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = e -> f e'
k e
e forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \e'
e' -> (a
a,b
b,c
c,d
d,e'
e',f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _5 #-}

-- | Provides access to the 6th element of a tuple.
class Field6 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 6th field of a tuple.
  _6 :: Lens s t a b
  default _6 :: (Generic s, Generic t, GIxed N5 (Rep s) (Rep t) a b)
             => Lens s t a b
  _6 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N5
proxyN5
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f) (a,b,c,d,e,f') f f' where
  _6 :: Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f')
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g) (a,b,c,d,e,f',g) f f' where
  _6 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f',g,h) f f' where
  _6 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f',g,h,i) f f' where
  _6 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j) (a,b,c,d,e,f',g,h,i,j) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f', g, h, i, j) f f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d,e,f',g,h,i,j,kk) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d, e, f', g, h, i, j, kk)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e,f',g,h,i,j,kk,l) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e, f', g, h, i, j, kk, l)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f',g,h,i,j,kk,l,m) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f', g, h, i, j, kk, l, m)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f',g,h,i,j,kk,l,m,n) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f', g, h, i, j, kk, l, m, n)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f',g,h,i,j,kk,l,m,n,o) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f',g,h,i,j,kk,l,m,n,o,p) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f',g,h,i,j,kk,l,m,n,o,p,q) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f',g,h,i,j,kk,l,m,n,o,p,q,r) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f',g,h,i,j,kk,l,m,n,o,p,q,r,s) f f' where
  _6 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s)
  f
  f'
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = f -> f f'
k f
f forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \f'
f' -> (a
a,b
b,c
c,d
d,e
e,f'
f',g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _6 #-}

-- | Provide access to the 7th field of a tuple.
class Field7 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 7th field of a tuple.
  _7 :: Lens s t a b
  default _7 :: (Generic s, Generic t, GIxed N6 (Rep s) (Rep t) a b)
             => Lens s t a b
  _7 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N6
proxyN6
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g) (a,b,c,d,e,f,g') g g' where
  _7 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g')
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f,g',h) g g' where
  _7 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g',h,i) g g' where
  _7 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j) (a,b,c,d,e,f,g',h,i,j) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g', h, i, j) g g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d,e,f,g',h,i,j,kk) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d, e, f, g', h, i, j, kk)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e,f,g',h,i,j,kk,l) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e, f, g', h, i, j, kk, l)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f,g',h,i,j,kk,l,m) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f, g', h, i, j, kk, l, m)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g',h,i,j,kk,l,m,n) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g', h, i, j, kk, l, m, n)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g',h,i,j,kk,l,m,n,o) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g',h,i,j,kk,l,m,n,o,p) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g',h,i,j,kk,l,m,n,o,p,q) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g',h,i,j,kk,l,m,n,o,p,q,r) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g',h,i,j,kk,l,m,n,o,p,q,r,s) g g' where
  _7 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s)
  g
  g'
_7 g -> f g'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = g -> f g'
k g
g forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \g'
g' -> (a
a,b
b,c
c,d
d,e
e,f
f,g'
g',h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _7 #-}

-- | Provide access to the 8th field of a tuple.
class Field8 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 8th field of a tuple.
  _8 :: Lens s t a b
  default _8 :: (Generic s, Generic t, GIxed N7 (Rep s) (Rep t) a b)
             => Lens s t a b
  _8 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N7
proxyN7
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f,g,h') h h' where
  _8 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h')
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g,h',i) h h' where
  _8 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j) (a,b,c,d,e,f,g,h',i,j) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h', i, j) h h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d,e,f,g,h',i,j,kk) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d, e, f, g, h', i, j, kk)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e,f,g,h',i,j,kk,l) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e, f, g, h', i, j, kk, l)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f,g,h',i,j,kk,l,m) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f, g, h', i, j, kk, l, m)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l,m
m)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g,h',i,j,kk,l,m,n) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g, h', i, j, kk, l, m, n)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h',i,j,kk,l,m,n,o) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h',i,j,kk,l,m,n,o,p) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h',i,j,kk,l,m,n,o,p,q) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h',i,j,kk,l,m,n,o,p,q,r) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h',i,j,kk,l,m,n,o,p,q,r,s) h h' where
  _8 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s)
  h
  h'
_8 h -> f h'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = h -> f h'
k h
h forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \h'
h' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h'
h',i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _8 #-}

-- | Provides access to the 9th field of a tuple.
class Field9 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 9th field of a tuple.
  _9 :: Lens s t a b
  default _9 :: (Generic s, Generic t, GIxed N8 (Rep s) (Rep t) a b)
             => Lens s t a b
  _9 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N8
proxyN8
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g,h,i') i i' where
  _9 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i')
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j) (a,b,c,d,e,f,g,h,i',j) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i', j) i i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d,e,f,g,h,i',j,kk) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d, e, f, g, h, i', j, kk)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e,f,g,h,i',j,kk,l) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e, f, g, h, i', j, kk, l)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f,g,h,i',j,kk,l,m) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f, g, h, i', j, kk, l, m)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l,m
m)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g,h,i',j,kk,l,m,n) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g, h, i', j, kk, l, m, n)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l,m
m,n
n)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h,i',j,kk,l,m,n,o) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i',j,kk,l,m,n,o,p) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i',j,kk,l,m,n,o,p,q) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i',j,kk,l,m,n,o,p,q,r) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i',j,kk,l,m,n,o,p,q,r,s) i i' where
  _9 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s)
  i
  i'
_9 i -> f i'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = i -> f i'
k i
i forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \i'
i' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i'
i',j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _9 #-}

-- | Provides access to the 10th field of a tuple.
class Field10 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 10th field of a tuple.
  _10 :: Lens s t a b
  default _10 :: (Generic s, Generic t, GIxed N9 (Rep s) (Rep t) a b)
             => Lens s t a b
  _10 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N9
proxyN9
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j) (a,b,c,d,e,f,g,h,i,j') j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j) (a, b, c, d, e, f, g, h, i, j') j j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j')
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d,e,f,g,h,i,j',kk) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d, e, f, g, h, i, j', kk)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e,f,g,h,i,j',kk,l) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e, f, g, h, i, j', kk, l)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f,g,h,i,j',kk,l,m) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f, g, h, i, j', kk, l, m)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l,m
m)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g,h,i,j',kk,l,m,n) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g, h, i, j', kk, l, m, n)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l,m
m,n
n)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h,i,j',kk,l,m,n,o) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l,m
m,n
n,o
o)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i,j',kk,l,m,n,o,p) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j',kk,l,m,n,o,p,q) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j',kk,l,m,n,o,p,q,r) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _10 #-}

instance Field10 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j',kk,l,m,n,o,p,q,r,s) j j' where
  _10 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s)
  j
  j'
_10 j -> f j'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = j -> f j'
k j
j forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \j'
j' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j'
j',kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _10 #-}

-- | Provides access to the 11th field of a tuple.
class Field11 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 11th field of a tuple.
  _11 :: Lens s t a b
  default _11 :: (Generic s, Generic t, GIxed N10 (Rep s) (Rep t) a b)
             => Lens s t a b
  _11 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N10
proxyN10
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk) (a,b,c,d,e,f,g,h,i,j,kk') kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk)
  (a, b, c, d, e, f, g, h, i, j, kk')
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk')
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e,f,g,h,i,j,kk',l) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e, f, g, h, i, j, kk', l)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l)
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f,g,h,i,j,kk',l,m) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f, g, h, i, j, kk', l, m)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l,m
m)
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g,h,i,j,kk',l,m,n) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g, h, i, j, kk', l, m, n)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l,m
m,n
n)
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h,i,j,kk',l,m,n,o) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l,m
m,n
n,o
o)
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i,j,kk',l,m,n,o,p) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l,m
m,n
n,o
o,p
p)
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j,kk',l,m,n,o,p,q) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l,m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk',l,m,n,o,p,q,r) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l,m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _11 #-}

instance Field11 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk',l,m,n,o,p,q,r,s) kk kk' where
  _11 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s)
  kk
  kk'
_11 kk -> f kk'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = kk -> f kk'
k kk
kk forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \kk'
kk' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk'
kk',l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _11 #-}

-- | Provides access to the 12th field of a tuple.
class Field12 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 12th field of a tuple.
  _12 :: Lens s t a b
  default _12 :: (Generic s, Generic t, GIxed N11 (Rep s) (Rep t) a b)
             => Lens s t a b
  _12 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N11
proxyN11
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l) (a,b,c,d,e,f,g,h,i,j,kk,l') l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l)
  (a, b, c, d, e, f, g, h, i, j, kk, l')
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l')
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f,g,h,i,j,kk,l',m) l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f, g, h, i, j, kk, l', m)
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l',m
m)
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g,h,i,j,kk,l',m,n) l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g, h, i, j, kk, l', m, n)
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l',m
m,n
n)
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h,i,j,kk,l',m,n,o) l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o)
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l',m
m,n
n,o
o)
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i,j,kk,l',m,n,o,p) l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p)
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l',m
m,n
n,o
o,p
p)
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j,kk,l',m,n,o,p,q) l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q)
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l',m
m,n
n,o
o,p
p,q
q)
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk,l',m,n,o,p,q,r) l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r)
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l',m
m,n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _12 #-}

instance Field12 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l',m,n,o,p,q,r,s) l l' where
  _12 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s)
  l
  l'
_12 l -> f l'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = l -> f l'
k l
l forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \l'
l' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l'
l',m
m,n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _12 #-}

-- | Provides access to the 13th field of a tuple.
class Field13 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 13th field of a tuple.
  _13 :: Lens s t a b
  default _13 :: (Generic s, Generic t, GIxed N12 (Rep s) (Rep t) a b)
             => Lens s t a b
  _13 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N12
proxyN12
  {-# INLINE _13 #-}

instance Field13 (a,b,c,d,e,f,g,h,i,j,kk,l,m) (a,b,c,d,e,f,g,h,i,j,kk,l,m') m m' where
  _13 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m')
  m
  m'
_13 m -> f m'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m) = m -> f m'
k m
m forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \m'
m' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m'
m')
  {-# INLINE _13 #-}

instance Field13 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g,h,i,j,kk,l,m',n) m m' where
  _13 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m', n)
  m
  m'
_13 m -> f m'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = m -> f m'
k m
m forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \m'
m' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m'
m',n
n)
  {-# INLINE _13 #-}

instance Field13 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h,i,j,kk,l,m',n,o) m m' where
  _13 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o)
  m
  m'
_13 m -> f m'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = m -> f m'
k m
m forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \m'
m' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m'
m',n
n,o
o)
  {-# INLINE _13 #-}

instance Field13 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i,j,kk,l,m',n,o,p) m m' where
  _13 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p)
  m
  m'
_13 m -> f m'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = m -> f m'
k m
m forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \m'
m' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m'
m',n
n,o
o,p
p)
  {-# INLINE _13 #-}

instance Field13 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j,kk,l,m',n,o,p,q) m m' where
  _13 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q)
  m
  m'
_13 m -> f m'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = m -> f m'
k m
m forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \m'
m' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m'
m',n
n,o
o,p
p,q
q)
  {-# INLINE _13 #-}

instance Field13 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk,l,m',n,o,p,q,r) m m' where
  _13 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r)
  m
  m'
_13 m -> f m'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = m -> f m'
k m
m forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \m'
m' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m'
m',n
n,o
o,p
p,q
q,r
r)
  {-# INLINE _13 #-}

instance Field13 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l,m',n,o,p,q,r,s) m m' where
  _13 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s)
  m
  m'
_13 m -> f m'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = m -> f m'
k m
m forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \m'
m' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m'
m',n
n,o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _13 #-}

-- | Provides access to the 14th field of a tuple.
class Field14 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 14th field of a tuple.
  _14 :: Lens s t a b
  default _14 :: (Generic s, Generic t, GIxed N13 (Rep s) (Rep t) a b)
             => Lens s t a b
  _14 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N13
proxyN13
  {-# INLINE _14 #-}

instance Field14 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n') n n' where
  _14 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n')
  n
  n'
_14 n -> f n'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n) = n -> f n'
k n
n forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \n'
n' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n'
n')
  {-# INLINE _14 #-}

instance Field14 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n',o) n n' where
  _14 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o)
  n
  n'
_14 n -> f n'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = n -> f n'
k n
n forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \n'
n' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n'
n',o
o)
  {-# INLINE _14 #-}

instance Field14 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n',o,p) n n' where
  _14 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p)
  n
  n'
_14 n -> f n'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = n -> f n'
k n
n forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \n'
n' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n'
n',o
o,p
p)
  {-# INLINE _14 #-}

instance Field14 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n',o,p,q) n n' where
  _14 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q)
  n
  n'
_14 n -> f n'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = n -> f n'
k n
n forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \n'
n' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n'
n',o
o,p
p,q
q)
  {-# INLINE _14 #-}

instance Field14 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n',o,p,q,r) n n' where
  _14 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r)
  n
  n'
_14 n -> f n'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = n -> f n'
k n
n forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \n'
n' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n'
n',o
o,p
p,q
q,r
r)
  {-# INLINE _14 #-}

instance Field14 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n',o,p,q,r,s) n n' where
  _14 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s)
  n
  n'
_14 n -> f n'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = n -> f n'
k n
n forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \n'
n' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n'
n',o
o,p
p,q
q,r
r,s
s)
  {-# INLINE _14 #-}

-- | Provides access to the 15th field of a tuple.
class Field15 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 15th field of a tuple.
  _15 :: Lens s t a b
  default _15 :: (Generic s, Generic t, GIxed N14 (Rep s) (Rep t) a b)
             => Lens s t a b
  _15 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N14
proxyN14
  {-# INLINE _15 #-}

instance Field15 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o') o o' where
  _15 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o')
  o
  o'
_15 o -> f o'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o) = o -> f o'
k o
o forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \o'
o' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o'
o')
  {-# INLINE _15 #-}

instance Field15 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o',p) o o' where
  _15 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p)
  o
  o'
_15 o -> f o'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = o -> f o'
k o
o forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \o'
o' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o'
o',p
p)
  {-# INLINE _15 #-}

instance Field15 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o',p,q) o o' where
  _15 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q)
  o
  o'
_15 o -> f o'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = o -> f o'
k o
o forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \o'
o' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o'
o',p
p,q
q)
  {-# INLINE _15 #-}

instance Field15 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o',p,q,r) o o' where
  _15 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r)
  o
  o'
_15 o -> f o'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = o -> f o'
k o
o forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \o'
o' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o'
o',p
p,q
q,r
r)
  {-# INLINE _15 #-}

instance Field15 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o',p,q,r,s) o o' where
  _15 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s)
  o
  o'
_15 o -> f o'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = o -> f o'
k o
o forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \o'
o' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o'
o',p
p,q
q,r
r,s
s)
  {-# INLINE _15 #-}

-- | Provides access to the 16th field of a tuple.
class Field16 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 16th field of a tuple.
  _16 :: Lens s t a b
  default _16 :: (Generic s, Generic t, GIxed N15 (Rep s) (Rep t) a b)
             => Lens s t a b
  _16 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N15
proxyN15
  {-# INLINE _16 #-}

instance Field16 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p') p p' where
  _16 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p')
  p
  p'
_16 p -> f p'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p) = p -> f p'
k p
p forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \p'
p' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p'
p')
  {-# INLINE _16 #-}

instance Field16 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p',q) p p' where
  _16 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q)
  p
  p'
_16 p -> f p'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = p -> f p'
k p
p forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \p'
p' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p'
p',q
q)
  {-# INLINE _16 #-}

instance Field16 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p',q,r) p p' where
  _16 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r)
  p
  p'
_16 p -> f p'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = p -> f p'
k p
p forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \p'
p' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p'
p',q
q,r
r)
  {-# INLINE _16 #-}

instance Field16 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p',q,r,s) p p' where
  _16 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s)
  p
  p'
_16 p -> f p'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = p -> f p'
k p
p forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \p'
p' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p'
p',q
q,r
r,s
s)
  {-# INLINE _16 #-}

-- | Provides access to the 17th field of a tuple.
class Field17 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 17th field of a tuple.
  _17 :: Lens s t a b
  default _17 :: (Generic s, Generic t, GIxed N16 (Rep s) (Rep t) a b)
             => Lens s t a b
  _17 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N16
proxyN16
  {-# INLINE _17 #-}

instance Field17 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q') q q' where
  _17 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q')
  q
  q'
_17 q -> f q'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q) = q -> f q'
k q
q forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \q'
q' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q'
q')
  {-# INLINE _17 #-}

instance Field17 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q',r) q q' where
  _17 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r)
  q
  q'
_17 q -> f q'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = q -> f q'
k q
q forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \q'
q' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q'
q',r
r)
  {-# INLINE _17 #-}

instance Field17 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q',r,s) q q' where
  _17 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s)
  q
  q'
_17 q -> f q'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = q -> f q'
k q
q forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \q'
q' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q'
q',r
r,s
s)
  {-# INLINE _17 #-}

-- | Provides access to the 18th field of a tuple.
class Field18 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 18th field of a tuple.
  _18 :: Lens s t a b
  default _18 :: (Generic s, Generic t, GIxed N17 (Rep s) (Rep t) a b)
             => Lens s t a b
  _18 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N17
proxyN17
  {-# INLINE _18 #-}

instance Field18 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r') r r' where
  _18 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r')
  r
  r'
_18 r -> f r'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r) = r -> f r'
k r
r forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \r'
r' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r'
r')
  {-# INLINE _18 #-}

instance Field18 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r',s) r r' where
  _18 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s)
  r
  r'
_18 r -> f r'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = r -> f r'
k r
r forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \r'
r' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r'
r',s
s)
  {-# INLINE _18 #-}

-- | Provides access to the 19th field of a tuple.
class Field19 s t a b | s -> a, t -> b, s b -> t, t a -> s where
  -- | Access the 19th field of a tuple.
  _19 :: Lens s t a b
  default _19 :: (Generic s, Generic t, GIxed N18 (Rep s) (Rep t) a b)
             => Lens s t a b
  _19 = forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N18
proxyN18
  {-# INLINE _19 #-}

instance Field19 (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s) (a,b,c,d,e,f,g,h,i,j,kk,l,m,n,o,p,q,r,s') s s' where
  _19 :: Lens
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
  (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s')
  s
  s'
_19 s -> f s'
k ~(a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s
s) = s -> f s'
k s
s forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \s'
s' -> (a
a,b
b,c
c,d
d,e
e,f
f,g
g,h
h,i
i,j
j,kk
kk,l
l,m
m,n
n,o
o,p
p,q
q,r
r,s'
s')
  {-# INLINE _19 #-}

-- Strict versions of the _1 .. _19 operations

-- | Strict version of '_1'
_1' :: Field1 s t a b => Lens s t a b
_1' :: forall s t a b. Field1 s t a b => Lens s t a b
_1' = \a -> f b
f !s
x -> forall s t a b. Field1 s t a b => Lens s t a b
_1 a -> f b
f s
x
{-# INLINE _1' #-}

-- | Strict version of '_2'
_2' :: Field2 s t a b => Lens s t a b
_2' :: forall s t a b. Field2 s t a b => Lens s t a b
_2' = \a -> f b
f !s
x -> forall s t a b. Field2 s t a b => Lens s t a b
_2 a -> f b
f s
x
{-# INLINE _2' #-}

-- | Strict version of '_3'
_3' :: Field3 s t a b => Lens s t a b
_3' :: forall s t a b. Field3 s t a b => Lens s t a b
_3' = \a -> f b
f !s
x -> forall s t a b. Field3 s t a b => Lens s t a b
_3 a -> f b
f s
x
{-# INLINE _3' #-}

-- | Strict version of '_4'
_4' :: Field4 s t a b => Lens s t a b
_4' :: forall s t a b. Field4 s t a b => Lens s t a b
_4' = \a -> f b
f !s
x -> forall s t a b. Field4 s t a b => Lens s t a b
_4 a -> f b
f s
x
{-# INLINE _4' #-}

-- | Strict version of '_5'
_5' :: Field5 s t a b => Lens s t a b
_5' :: forall s t a b. Field5 s t a b => Lens s t a b
_5' = \a -> f b
f !s
x -> forall s t a b. Field5 s t a b => Lens s t a b
_5 a -> f b
f s
x
{-# INLINE _5' #-}

-- | Strict version of '_6'
_6' :: Field6 s t a b => Lens s t a b
_6' :: forall s t a b. Field6 s t a b => Lens s t a b
_6' = \a -> f b
f !s
x -> forall s t a b. Field6 s t a b => Lens s t a b
_6 a -> f b
f s
x
{-# INLINE _6' #-}

-- | Strict version of '_7'
_7' :: Field7 s t a b => Lens s t a b
_7' :: forall s t a b. Field7 s t a b => Lens s t a b
_7' = \a -> f b
f !s
x -> forall s t a b. Field7 s t a b => Lens s t a b
_7 a -> f b
f s
x
{-# INLINE _7' #-}

-- | Strict version of '_8'
_8' :: Field8 s t a b => Lens s t a b
_8' :: forall s t a b. Field8 s t a b => Lens s t a b
_8' = \a -> f b
f !s
x -> forall s t a b. Field8 s t a b => Lens s t a b
_8 a -> f b
f s
x
{-# INLINE _8' #-}

-- | Strict version of '_9'
_9' :: Field9 s t a b => Lens s t a b
_9' :: forall s t a b. Field9 s t a b => Lens s t a b
_9' = \a -> f b
f !s
x -> forall s t a b. Field9 s t a b => Lens s t a b
_9 a -> f b
f s
x
{-# INLINE _9' #-}

-- | Strict version of '_10'
_10' :: Field10 s t a b => Lens s t a b
_10' :: forall s t a b. Field10 s t a b => Lens s t a b
_10' = \a -> f b
f !s
x -> forall s t a b. Field10 s t a b => Lens s t a b
_10 a -> f b
f s
x
{-# INLINE _10' #-}

-- | Strict version of '_11'
_11' :: Field11 s t a b => Lens s t a b
_11' :: forall s t a b. Field11 s t a b => Lens s t a b
_11' = \a -> f b
f !s
x -> forall s t a b. Field11 s t a b => Lens s t a b
_11 a -> f b
f s
x
{-# INLINE _11' #-}

-- | Strict version of '_12'
_12' :: Field12 s t a b => Lens s t a b
_12' :: forall s t a b. Field12 s t a b => Lens s t a b
_12' = \a -> f b
f !s
x -> forall s t a b. Field12 s t a b => Lens s t a b
_12 a -> f b
f s
x
{-# INLINE _12' #-}

-- | Strict version of '_13'
_13' :: Field13 s t a b => Lens s t a b
_13' :: forall s t a b. Field13 s t a b => Lens s t a b
_13' = \a -> f b
f !s
x -> forall s t a b. Field13 s t a b => Lens s t a b
_13 a -> f b
f s
x
{-# INLINE _13' #-}

-- | Strict version of '_14'
_14' :: Field14 s t a b => Lens s t a b
_14' :: forall s t a b. Field14 s t a b => Lens s t a b
_14' = \a -> f b
f !s
x -> forall s t a b. Field14 s t a b => Lens s t a b
_14 a -> f b
f s
x
{-# INLINE _14' #-}

-- | Strict version of '_15'
_15' :: Field15 s t a b => Lens s t a b
_15' :: forall s t a b. Field15 s t a b => Lens s t a b
_15' = \a -> f b
f !s
x -> forall s t a b. Field15 s t a b => Lens s t a b
_15 a -> f b
f s
x
{-# INLINE _15' #-}

-- | Strict version of '_16'
_16' :: Field16 s t a b => Lens s t a b
_16' :: forall s t a b. Field16 s t a b => Lens s t a b
_16' = \a -> f b
f !s
x -> forall s t a b. Field16 s t a b => Lens s t a b
_16 a -> f b
f s
x
{-# INLINE _16' #-}

-- | Strict version of '_17'
_17' :: Field17 s t a b => Lens s t a b
_17' :: forall s t a b. Field17 s t a b => Lens s t a b
_17' = \a -> f b
f !s
x -> forall s t a b. Field17 s t a b => Lens s t a b
_17 a -> f b
f s
x
{-# INLINE _17' #-}

-- | Strict version of '_18'
_18' :: Field18 s t a b => Lens s t a b
_18' :: forall s t a b. Field18 s t a b => Lens s t a b
_18' = \a -> f b
f !s
x -> forall s t a b. Field18 s t a b => Lens s t a b
_18 a -> f b
f s
x
{-# INLINE _18' #-}

-- | Strict version of '_19'
_19' :: Field19 s t a b => Lens s t a b
_19' :: forall s t a b. Field19 s t a b => Lens s t a b
_19' = \a -> f b
f !s
x -> forall s t a b. Field19 s t a b => Lens s t a b
_19 a -> f b
f s
x
{-# INLINE _19' #-}


ix :: (Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) => f n -> Lens s t a b
ix :: forall {k} s t (n :: k) a b (f :: k -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix f n
n a -> f b
f = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a x. Generic a => Rep a x -> a
to forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} {k} (n :: k) (s :: k -> *) (t :: k -> *) a b
       (f :: k -> *) (x :: k).
GIxed n s t a b =>
f n -> Lens (s x) (t x) a b
gix f n
n a -> f b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a x. Generic a => a -> Rep a x
from
{-# INLINE ix #-}

type family GSize (f :: Type -> Type)
type instance GSize U1 = Z
type instance GSize (K1 i c) = S Z
type instance GSize (M1 i c f) = GSize f
type instance GSize (a :*: b) = Add (GSize a) (GSize b)

class GIxed n s t a b | n s -> a, n t -> b, n s b -> t, n t a -> s where
  gix :: f n -> Lens (s x) (t x) a b

instance GIxed N0 (K1 i a) (K1 i b) a b where
  gix :: forall (f :: * -> *) (x :: k).
f N0 -> Lens (K1 i a x) (K1 i b x) a b
gix f N0
_ = forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap forall k i c (p :: k). K1 i c p -> c
unK1 (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall k i c (p :: k). c -> K1 i c p
K1)
  {-# INLINE gix #-}

instance GIxed n s t a b => GIxed n (M1 i c s) (M1 i c t) a b where
  gix :: forall (f :: k -> *) (x :: k).
f n -> Lens (M1 i c s x) (M1 i c t x) a b
gix f n
n = forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap forall k i (c :: Meta) (f :: k -> *) (p :: k). M1 i c f p -> f p
unM1 (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall {k} {k} (n :: k) (s :: k -> *) (t :: k -> *) a b
       (f :: k -> *) (x :: k).
GIxed n s t a b =>
f n -> Lens (s x) (t x) a b
gix f n
n
  {-# INLINE gix #-}

instance (p ~ GT (GSize s) n,
          p ~ GT (GSize t) n,
          GIxed' p n s s' t t' a b)
      => GIxed n (s :*: s') (t :*: t') a b where
  gix :: forall (f :: * -> *) x.
f n -> Lens ((:*:) s s' x) ((:*:) t t' x) a b
gix = forall p n (s :: * -> *) (s' :: * -> *) (t :: * -> *)
       (t' :: * -> *) a b (f :: * -> *) (g :: * -> *) x.
GIxed' p n s s' t t' a b =>
f p -> g n -> Lens ((:*:) s s' x) ((:*:) t t' x) a b
gix' (forall {k} (t :: k). Proxy t
Proxy :: Proxy p)
  {-# INLINE gix #-}

-- $gixed-fundeps
-- >>> :set -XDeriveGeneric -XFlexibleInstances -XMultiParamTypeClasses
-- >>> import GHC.Generics (Generic)
-- >>> data Product a b = a :* b deriving Generic
-- >>> instance Field1 (Product a b) (Product a' b) a a'
-- >>> instance Field2 (Product a b) (Product a b') b b'

class (p ~ GT (GSize s) n,
       p ~ GT (GSize t) n)
   => GIxed' p n s s' t t' a b | p n s s' -> a
                               , p n t t' -> b
                               , p n s s' b -> t t'
                               , p n t t' a -> s s' where
  gix' :: f p -> g n -> Lens ((s :*: s') x) ((t :*: t') x) a b

instance (GT (GSize s) n ~ T,
          GT (GSize t) n ~ T,
          GIxed n s t a b)
      => GIxed' T n s s' t s' a b where
  gix' :: forall (f :: * -> *) (g :: * -> *) x.
f T -> g n -> Lens ((:*:) s s' x) ((:*:) t s' x) a b
gix' f T
_ g n
n a -> f b
f (s x
s :*: s' x
s') = (forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: s' x
s') forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {k} {k} (n :: k) (s :: k -> *) (t :: k -> *) a b
       (f :: k -> *) (x :: k).
GIxed n s t a b =>
f n -> Lens (s x) (t x) a b
gix g n
n a -> f b
f s x
s
  {-# INLINE gix' #-}

instance (GT (GSize s) n ~ F,
          n' ~ Subtract (GSize s) n,
          GIxed n' s' t' a b)
      => GIxed' F n s s' s t' a b where
  gix' :: forall (f :: * -> *) (g :: * -> *) x.
f F -> g n -> Lens ((:*:) s s' x) ((:*:) s t' x) a b
gix' f F
_ g n
_  a -> f b
f (s x
s :*: s' x
s') = (s x
s forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall {k} {k} (n :: k) (s :: k -> *) (t :: k -> *) a b
       (f :: k -> *) (x :: k).
GIxed n s t a b =>
f n -> Lens (s x) (t x) a b
gix (forall {k} (t :: k). Proxy t
Proxy :: Proxy n') a -> f b
f s' x
s'
  {-# INLINE gix' #-}

data Z
data S a

data T
data F

type family Add x y
type instance Add Z y = y
type instance Add (S x) y = S (Add x y)

type family Subtract x y
type instance Subtract Z x = x
type instance Subtract (S x) (S y) = Subtract x y

type family GT x y
type instance GT Z x = F
type instance GT (S x) Z = T
type instance GT (S x) (S y) = GT x y

type N0 = Z
type N1 = S N0
type N2 = S N1
type N3 = S N2
type N4 = S N3
type N5 = S N4
type N6 = S N5
type N7 = S N6
type N8 = S N7
type N9 = S N8
type N10 = S N9
type N11 = S N10
type N12 = S N11
type N13 = S N12
type N14 = S N13
type N15 = S N14
type N16 = S N15
type N17 = S N16
type N18 = S N17

proxyN0 :: Proxy N0
proxyN0 :: Proxy N0
proxyN0 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN0 #-}

proxyN1 :: Proxy N1
proxyN1 :: Proxy N1
proxyN1 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN1 #-}

proxyN2 :: Proxy N2
proxyN2 :: Proxy N2
proxyN2 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN2 #-}

proxyN3 :: Proxy N3
proxyN3 :: Proxy N3
proxyN3 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN3 #-}

proxyN4 :: Proxy N4
proxyN4 :: Proxy N4
proxyN4 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN4 #-}

proxyN5 :: Proxy N5
proxyN5 :: Proxy N5
proxyN5 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN5 #-}

proxyN6 :: Proxy N6
proxyN6 :: Proxy N6
proxyN6 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN6 #-}

proxyN7 :: Proxy N7
proxyN7 :: Proxy N7
proxyN7 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN7 #-}

proxyN8 :: Proxy N8
proxyN8 :: Proxy N8
proxyN8 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN8 #-}

proxyN9 :: Proxy N9
proxyN9 :: Proxy N9
proxyN9 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN9 #-}

proxyN10 :: Proxy N10
proxyN10 :: Proxy N10
proxyN10 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN10 #-}

proxyN11 :: Proxy N11
proxyN11 :: Proxy N11
proxyN11 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN11 #-}

proxyN12 :: Proxy N12
proxyN12 :: Proxy N12
proxyN12 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN12 #-}

proxyN13 :: Proxy N13
proxyN13 :: Proxy N13
proxyN13 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN13 #-}

proxyN14 :: Proxy N14
proxyN14 :: Proxy N14
proxyN14 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN14 #-}

proxyN15 :: Proxy N15
proxyN15 :: Proxy N15
proxyN15 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN15 #-}

proxyN16 :: Proxy N16
proxyN16 :: Proxy N16
proxyN16 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN16 #-}

proxyN17 :: Proxy N17
proxyN17 :: Proxy N17
proxyN17 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN17 #-}

proxyN18 :: Proxy N18
proxyN18 :: Proxy N18
proxyN18 = forall {k} (t :: k). Proxy t
Proxy
{-# INLINE proxyN18 #-}