{-# 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 = Proxy N0 -> Lens s t a b
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 :: (a -> f b) -> Identity a -> f (Identity b)
_1 a -> f b
f (Identity a
a) = b -> Identity b
forall a. a -> Identity a
Identity (b -> Identity b) -> f b -> f (Identity b)
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 :: (f a -> f (f' a)) -> Product f g a -> f (Product f' g a)
_1 f a -> f (f' a)
f (Pair f a
a g a
b) = (f' a -> g a -> Product f' g a) -> g a -> f' a -> Product f' g a
forall a b c. (a -> b -> c) -> b -> a -> c
flip f' a -> g a -> Product f' g a
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair g a
b (f' a -> Product f' g a) -> f (f' a) -> f (Product f' g a)
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 :: (f p -> f (f' p)) -> (:*:) f g p -> f ((:*:) f' g p)
_1 f p -> f (f' p)
f (f p
l :*: g p
r) = (f' p -> g p -> (:*:) f' g p
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: g p
r) (f' p -> (:*:) f' g p) -> f (f' p) -> f ((:*:) f' g p)
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 :: (a -> f a') -> Pair a b -> f (Pair a' b)
_1 a -> f a'
f (a
a :!: b
b) = (a' -> b -> Pair a' b
forall a b. a -> b -> Pair a b
:!: b
b) (a' -> Pair a' b) -> f a' -> f (Pair a' 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 :: (a -> f a') -> (a, b) -> f (a', b)
_1 a -> f a'
k ~(a
a,b
b) = a -> f a'
k a
a f a' -> (a' -> (a', b)) -> f (a', b)
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 :: (a -> f a') -> (a, b, c) -> f (a', b, c)
_1 a -> f a'
k ~(a
a,b
b,c
c) = a -> f a'
k a
a f a' -> (a' -> (a', b, c)) -> f (a', b, c)
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 :: (a -> f a') -> (a, b, c, d) -> f (a', b, c, d)
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d) = a -> f a'
k a
a f a' -> (a' -> (a', b, c, d)) -> f (a', b, c, d)
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 :: (a -> f a') -> (a, b, c, d, e) -> f (a', b, c, d, e)
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e) = a -> f a'
k a
a f a' -> (a' -> (a', b, c, d, e)) -> f (a', b, c, d, e)
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 :: (a -> f a') -> (a, b, c, d, e, f) -> f (a', b, c, d, e, f)
_1 a -> f a'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = a -> f a'
k a
a f a' -> (a' -> (a', b, c, d, e, f)) -> f (a', b, c, d, e, f)
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 :: (a -> f a') -> (a, b, c, d, e, f, g) -> f (a', b, c, d, e, f, g)
_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 f a' -> (a' -> (a', b, c, d, e, f, g)) -> f (a', b, c, d, e, f, g)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h) -> f (a', b, c, d, e, f, g, h)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h)) -> f (a', b, c, d, e, f, g, h)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i) -> f (a', b, c, d, e, f, g, h, i)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i))
-> f (a', b, c, d, e, f, g, h, i)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a', b, c, d, e, f, g, h, i, j)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j))
-> f (a', b, c, d, e, f, g, h, i, j)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a', b, c, d, e, f, g, h, i, j, kk)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk))
-> f (a', b, c, d, e, f, g, h, i, j, kk)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk, l))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk, l, m))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk, l, m, n))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
_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 f a'
-> (a' -> (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
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 :: (a -> f a')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
_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 f a'
-> (a'
    -> (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s))
-> f (a', b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N1 -> Lens s t a b
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 :: (g a -> f (g' a)) -> Product f g a -> f (Product f g' a)
_2 g a -> f (g' a)
f (Pair f a
a g a
b) = f a -> g' a -> Product f g' a
forall k (f :: k -> *) (g :: k -> *) (a :: k).
f a -> g a -> Product f g a
Pair f a
a (g' a -> Product f g' a) -> f (g' a) -> f (Product f g' 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 :: (g p -> f (g' p)) -> (:*:) f g p -> f ((:*:) f g' p)
_2 g p -> f (g' p)
f (f p
l :*: g p
r) = (f p
l f p -> g' p -> (:*:) f g' p
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*:) (g' p -> (:*:) f g' p) -> f (g' p) -> f ((:*:) 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 :: (b -> f b') -> Pair a b -> f (Pair a b')
_2 b -> f b'
f (a
a :!: b
b) = (a
a a -> b' -> Pair a b'
forall a b. a -> b -> Pair a b
:!:) (b' -> Pair a b') -> f b' -> f (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 :: (b -> f b') -> (a, b) -> f (a, b')
_2 b -> f b'
k ~(a
a,b
b) = b -> f b'
k b
b f b' -> (b' -> (a, b')) -> f (a, 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 :: (b -> f b') -> (a, b, c) -> f (a, b', c)
_2 b -> f b'
k ~(a
a,b
b,c
c) = b -> f b'
k b
b f b' -> (b' -> (a, b', c)) -> f (a, b', c)
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 :: (b -> f b') -> (a, b, c, d) -> f (a, b', c, d)
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d) = b -> f b'
k b
b f b' -> (b' -> (a, b', c, d)) -> f (a, b', c, d)
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 :: (b -> f b') -> (a, b, c, d, e) -> f (a, b', c, d, e)
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e) = b -> f b'
k b
b f b' -> (b' -> (a, b', c, d, e)) -> f (a, b', c, d, e)
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 :: (b -> f b') -> (a, b, c, d, e, f) -> f (a, b', c, d, e, f)
_2 b -> f b'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = b -> f b'
k b
b f b' -> (b' -> (a, b', c, d, e, f)) -> f (a, b', c, d, e, f)
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 :: (b -> f b') -> (a, b, c, d, e, f, g) -> f (a, b', c, d, e, f, g)
_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 f b' -> (b' -> (a, b', c, d, e, f, g)) -> f (a, b', c, d, e, f, g)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h) -> f (a, b', c, d, e, f, g, h)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h)) -> f (a, b', c, d, e, f, g, h)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b', c, d, e, f, g, h, i)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i))
-> f (a, b', c, d, e, f, g, h, i)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b', c, d, e, f, g, h, i, j)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j))
-> f (a, b', c, d, e, f, g, h, i, j)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b', c, d, e, f, g, h, i, j, kk)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk))
-> f (a, b', c, d, e, f, g, h, i, j, kk)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk, l))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk, l, m))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk, l, m, n))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
_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 f b'
-> (b' -> (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
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 :: (b -> f b')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
_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 f b'
-> (b'
    -> (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s))
-> f (a, b', c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N2 -> Lens s t a b
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 :: (c -> f c') -> (a, b, c) -> f (a, b, c')
_3 c -> f c'
k ~(a
a,b
b,c
c) = c -> f c'
k c
c f c' -> (c' -> (a, b, c')) -> f (a, b, 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 :: (c -> f c') -> (a, b, c, d) -> f (a, b, c', d)
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d) = c -> f c'
k c
c f c' -> (c' -> (a, b, c', d)) -> f (a, b, c', d)
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 :: (c -> f c') -> (a, b, c, d, e) -> f (a, b, c', d, e)
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e) = c -> f c'
k c
c f c' -> (c' -> (a, b, c', d, e)) -> f (a, b, c', d, e)
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 :: (c -> f c') -> (a, b, c, d, e, f) -> f (a, b, c', d, e, f)
_3 c -> f c'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = c -> f c'
k c
c f c' -> (c' -> (a, b, c', d, e, f)) -> f (a, b, c', d, e, f)
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 :: (c -> f c') -> (a, b, c, d, e, f, g) -> f (a, b, c', d, e, f, g)
_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 f c' -> (c' -> (a, b, c', d, e, f, g)) -> f (a, b, c', d, e, f, g)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h) -> f (a, b, c', d, e, f, g, h)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h)) -> f (a, b, c', d, e, f, g, h)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b, c', d, e, f, g, h, i)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i))
-> f (a, b, c', d, e, f, g, h, i)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c', d, e, f, g, h, i, j)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j))
-> f (a, b, c', d, e, f, g, h, i, j)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c', d, e, f, g, h, i, j, kk)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk))
-> f (a, b, c', d, e, f, g, h, i, j, kk)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk, l))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk, l, m))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk, l, m, n))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
_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 f c'
-> (c' -> (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
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 :: (c -> f c')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
_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 f c'
-> (c'
    -> (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s))
-> f (a, b, c', d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N3 -> Lens s t a b
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 :: (d -> f d') -> (a, b, c, d) -> f (a, b, c, d')
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d) = d -> f d'
k d
d f d' -> (d' -> (a, b, c, d')) -> f (a, b, c, 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 :: (d -> f d') -> (a, b, c, d, e) -> f (a, b, c, d', e)
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e) = d -> f d'
k d
d f d' -> (d' -> (a, b, c, d', e)) -> f (a, b, c, d', e)
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 :: (d -> f d') -> (a, b, c, d, e, f) -> f (a, b, c, d', e, f)
_4 d -> f d'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = d -> f d'
k d
d f d' -> (d' -> (a, b, c, d', e, f)) -> f (a, b, c, d', e, f)
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 :: (d -> f d') -> (a, b, c, d, e, f, g) -> f (a, b, c, d', e, f, g)
_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 f d' -> (d' -> (a, b, c, d', e, f, g)) -> f (a, b, c, d', e, f, g)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h) -> f (a, b, c, d', e, f, g, h)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h)) -> f (a, b, c, d', e, f, g, h)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b, c, d', e, f, g, h, i)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i))
-> f (a, b, c, d', e, f, g, h, i)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c, d', e, f, g, h, i, j)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j))
-> f (a, b, c, d', e, f, g, h, i, j)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d', e, f, g, h, i, j, kk)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk))
-> f (a, b, c, d', e, f, g, h, i, j, kk)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk, l))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk, l, m))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk, l, m, n))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
_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 f d'
-> (d' -> (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
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 :: (d -> f d')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
_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 f d'
-> (d'
    -> (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s))
-> f (a, b, c, d', e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N4 -> Lens s t a b
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 :: (e -> f e') -> (a, b, c, d, e) -> f (a, b, c, d, e')
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e) = e -> f e'
k e
e f e' -> (e' -> (a, b, c, d, e')) -> f (a, b, c, d, 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 :: (e -> f e') -> (a, b, c, d, e, f) -> f (a, b, c, d, e', f)
_5 e -> f e'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = e -> f e'
k e
e f e' -> (e' -> (a, b, c, d, e', f)) -> f (a, b, c, d, e', f)
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 :: (e -> f e') -> (a, b, c, d, e, f, g) -> f (a, b, c, d, e', f, g)
_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 f e' -> (e' -> (a, b, c, d, e', f, g)) -> f (a, b, c, d, e', f, g)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h) -> f (a, b, c, d, e', f, g, h)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h)) -> f (a, b, c, d, e', f, g, h)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b, c, d, e', f, g, h, i)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i))
-> f (a, b, c, d, e', f, g, h, i)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c, d, e', f, g, h, i, j)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j))
-> f (a, b, c, d, e', f, g, h, i, j)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d, e', f, g, h, i, j, kk)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk))
-> f (a, b, c, d, e', f, g, h, i, j, kk)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk, l))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk, l, m))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk, l, m, n))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r)
_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 f e'
-> (e' -> (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r)
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 :: (e -> f e')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
_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 f e'
-> (e'
    -> (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s))
-> f (a, b, c, d, e', f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N5 -> Lens s t a b
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 :: (f -> f f') -> (a, b, c, d, e, f) -> f (a, b, c, d, e, f')
_6 f -> f f'
k ~(a
a,b
b,c
c,d
d,e
e,f
f) = f -> f f'
k f
f f f' -> (f' -> (a, b, c, d, e, f')) -> f (a, b, c, d, e, 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 :: (f -> f f') -> (a, b, c, d, e, f, g) -> f (a, b, c, d, e, f', g)
_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 f f' -> (f' -> (a, b, c, d, e, f', g)) -> f (a, b, c, d, e, f', g)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h) -> f (a, b, c, d, e, f', g, h)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h)) -> f (a, b, c, d, e, f', g, h)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b, c, d, e, f', g, h, i)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i))
-> f (a, b, c, d, e, f', g, h, i)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c, d, e, f', g, h, i, j)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j))
-> f (a, b, c, d, e, f', g, h, i, j)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d, e, f', g, h, i, j, kk)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk))
-> f (a, b, c, d, e, f', g, h, i, j, kk)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk, l))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk, l, m))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk, l, m, n))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r)
_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 f f'
-> (f' -> (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r)
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 :: (f -> f f')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s)
_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 f f'
-> (f'
    -> (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s))
-> f (a, b, c, d, e, f', g, h, i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N6 -> Lens s t a b
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 :: (g -> f g') -> (a, b, c, d, e, f, g) -> f (a, b, c, d, e, f, 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 f g' -> (g' -> (a, b, c, d, e, f, g')) -> f (a, b, c, d, e, f, 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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h) -> f (a, b, c, d, e, f, g', h)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h)) -> f (a, b, c, d, e, f, g', h)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b, c, d, e, f, g', h, i)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i))
-> f (a, b, c, d, e, f, g', h, i)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c, d, e, f, g', h, i, j)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j))
-> f (a, b, c, d, e, f, g', h, i, j)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d, e, f, g', h, i, j, kk)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk))
-> f (a, b, c, d, e, f, g', h, i, j, kk)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk, l))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk, l, m))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk, l, m, n))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r)
_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 f g'
-> (g' -> (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r)
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 :: (g -> f g')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s)
_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 f g'
-> (g'
    -> (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s))
-> f (a, b, c, d, e, f, g', h, i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N7 -> Lens s t a b
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h) -> f (a, b, c, d, e, f, g, 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 f h'
-> (h' -> (a, b, c, d, e, f, g, h')) -> f (a, b, c, d, e, f, g, 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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b, c, d, e, f, g, h', i)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i))
-> f (a, b, c, d, e, f, g, h', i)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c, d, e, f, g, h', i, j)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j))
-> f (a, b, c, d, e, f, g, h', i, j)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d, e, f, g, h', i, j, kk)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk))
-> f (a, b, c, d, e, f, g, h', i, j, kk)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk, l))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk, l, m))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk, l, m, n))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r)
_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 f h'
-> (h' -> (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r)
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 :: (h -> f h')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s)
_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 f h'
-> (h'
    -> (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s))
-> f (a, b, c, d, e, f, g, h', i, j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N8 -> Lens s t a b
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i) -> f (a, b, c, d, e, f, g, h, 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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i'))
-> f (a, b, c, d, e, f, g, h, 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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c, d, e, f, g, h, i', j)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j))
-> f (a, b, c, d, e, f, g, h, i', j)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d, e, f, g, h, i', j, kk)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk))
-> f (a, b, c, d, e, f, g, h, i', j, kk)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk, l))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk, l, m))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk, l, m, n))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r)
_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 f i'
-> (i' -> (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r)
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 :: (i -> f i')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s)
_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 f i'
-> (i'
    -> (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s))
-> f (a, b, c, d, e, f, g, h, i', j, kk, l, m, n, o, p, q, r, s)
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 = Proxy N9 -> Lens s t a b
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j)
-> f (a, b, c, d, e, f, g, h, i, 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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j'))
-> f (a, b, c, d, e, f, g, h, i, 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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d, e, f, g, h, i, j', kk)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk))
-> f (a, b, c, d, e, f, g, h, i, j', kk)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk, l))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk, l, m))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk, l, m, n))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r)
_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 f j'
-> (j' -> (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r)
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 :: (j -> f j')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s)
_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 f j'
-> (j'
    -> (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s))
-> f (a, b, c, d, e, f, g, h, i, j', kk, l, m, n, o, p, q, r, s)
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 = Proxy N10 -> Lens s t a b
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk)
-> f (a, b, c, d, e, f, g, h, i, j, 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 f kk'
-> (kk' -> (a, b, c, d, e, f, g, h, i, j, kk'))
-> f (a, b, c, d, e, f, g, h, i, j, 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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l)
_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 f kk'
-> (kk' -> (a, b, c, d, e, f, g, h, i, j, kk', l))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l)
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m)
_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 f kk'
-> (kk' -> (a, b, c, d, e, f, g, h, i, j, kk', l, m))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m)
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n)
_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 f kk'
-> (kk' -> (a, b, c, d, e, f, g, h, i, j, kk', l, m, n))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n)
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o)
_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 f kk'
-> (kk' -> (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o)
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p)
_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 f kk'
-> (kk' -> (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p)
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q)
_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 f kk'
-> (kk' -> (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q)
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r)
_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 f kk'
-> (kk'
    -> (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r)
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 :: (kk -> f kk')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s)
_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 f kk'
-> (kk'
    -> (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s))
-> f (a, b, c, d, e, f, g, h, i, j, kk', l, m, n, o, p, q, r, s)
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 = Proxy N11 -> Lens s t a b
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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l)
-> f (a, b, c, d, e, f, g, h, i, j, kk, 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 f l'
-> (l' -> (a, b, c, d, e, f, g, h, i, j, kk, l'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, 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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m)
_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 f l'
-> (l' -> (a, b, c, d, e, f, g, h, i, j, kk, l', m))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m)
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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n)
_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 f l'
-> (l' -> (a, b, c, d, e, f, g, h, i, j, kk, l', m, n))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n)
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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o)
_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 f l'
-> (l' -> (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o)
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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p)
_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 f l'
-> (l' -> (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p)
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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q)
_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 f l'
-> (l' -> (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q)
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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r)
_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 f l'
-> (l' -> (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r)
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 :: (l -> f l')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s)
_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 f l'
-> (l'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l', m, n, o, p, q, r, s)
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 = Proxy N12 -> Lens s t a b
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 :: (m -> f m')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, 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 f m'
-> (m' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, 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 :: (m -> f m')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n)
_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 f m'
-> (m' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m', n))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n)
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 :: (m -> f m')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o)
_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 f m'
-> (m' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o)
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 :: (m -> f m')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p)
_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 f m'
-> (m' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p)
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 :: (m -> f m')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q)
_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 f m'
-> (m' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q)
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 :: (m -> f m')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r)
_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 f m'
-> (m' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r)
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 :: (m -> f m')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s)
_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 f m'
-> (m'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m', n, o, p, q, r, s)
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 = Proxy N13 -> Lens s t a b
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 :: (n -> f n')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, 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 f n'
-> (n' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, 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 :: (n -> f n')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o)
_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 f n'
-> (n' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o)
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 :: (n -> f n')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p)
_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 f n'
-> (n' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p)
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 :: (n -> f n')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q)
_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 f n'
-> (n' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q)
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 :: (n -> f n')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r)
_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 f n'
-> (n' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r)
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 :: (n -> f n')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s)
_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 f n'
-> (n'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n', o, p, q, r, s)
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 = Proxy N14 -> Lens s t a b
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 :: (o -> f o')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, 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 f o'
-> (o' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, 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 :: (o -> f o')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p)
_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 f o'
-> (o' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p)
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 :: (o -> f o')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q)
_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 f o'
-> (o' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q)
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 :: (o -> f o')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r)
_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 f o'
-> (o' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r)
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 :: (o -> f o')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s)
_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 f o'
-> (o'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o', p, q, r, s)
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 = Proxy N15 -> Lens s t a b
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 :: (p -> f p')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, 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 f p'
-> (p' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, 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 :: (p -> f p')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q)
_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 f p'
-> (p' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q)
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 :: (p -> f p')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r)
_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 f p'
-> (p' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r)
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 :: (p -> f p')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s)
_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 f p'
-> (p'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p', q, r, s)
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 = Proxy N16 -> Lens s t a b
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 :: (q -> f q')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, 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 f q'
-> (q' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, 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 :: (q -> f q')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r)
_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 f q'
-> (q' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r)
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 :: (q -> f q')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s)
_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 f q'
-> (q'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q', r, s)
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 = Proxy N17 -> Lens s t a b
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 :: (r -> f r')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, 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 f r'
-> (r' -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, 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 :: (r -> f r')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s)
_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 f r'
-> (r'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r', s)
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 = Proxy N18 -> Lens s t a b
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 :: (s -> f s')
-> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s)
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, 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 f s'
-> (s'
    -> (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, s'))
-> f (a, b, c, d, e, f, g, h, i, j, kk, l, m, n, o, p, q, r, 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' :: Lens s t a b
_1' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_2' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_3' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_4' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_5' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_6' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_7' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_8' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_9' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_10' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_11' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_12' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_13' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_14' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_15' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_16' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_17' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_18' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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' :: Lens s t a b
_19' = \a -> f b
f !s
x -> (a -> f b) -> s -> f t
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 :: f n -> Lens s t a b
ix f n
n a -> f b
f = (Rep t Any -> t) -> f (Rep t Any) -> f t
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Rep t Any -> t
forall a x. Generic a => Rep a x -> a
to (f (Rep t Any) -> f t) -> (s -> f (Rep t Any)) -> s -> f t
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f n -> (a -> f b) -> Rep s Any -> f (Rep t Any)
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 (Rep s Any -> f (Rep t Any))
-> (s -> Rep s Any) -> s -> f (Rep t Any)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. s -> Rep s Any
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 :: f N0 -> Lens (K1 i a x) (K1 i b x) a b
gix f N0
_ = (K1 i a x -> a)
-> (f b -> f (K1 i b x)) -> (a -> f b) -> K1 i a x -> f (K1 i b x)
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap K1 i a x -> a
forall i c k (p :: k). K1 i c p -> c
unK1 ((b -> K1 i b x) -> f b -> f (K1 i b x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> K1 i b x
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 :: f n -> Lens (M1 i c s x) (M1 i c t x) a b
gix f n
n = (M1 i c s x -> s x)
-> (f (t x) -> f (M1 i c t x))
-> (s x -> f (t x))
-> M1 i c s x
-> f (M1 i c t x)
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap M1 i c s x -> s x
forall i (c :: Meta) k (f :: k -> *) (p :: k). M1 i c f p -> f p
unM1 ((t x -> M1 i c t x) -> f (t x) -> f (M1 i c t x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap t x -> M1 i c t x
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1) ((s x -> f (t x)) -> M1 i c s x -> f (M1 i c t x))
-> ((a -> f b) -> s x -> f (t x))
-> (a -> f b)
-> M1 i c s x
-> f (M1 i c t x)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f n -> Lens (s x) (t x) a 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 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 :: f n -> Lens ((:*:) s s' x) ((:*:) t t' x) a b
gix = Proxy p -> f n -> Lens ((:*:) s s' x) ((:*:) t t' x) a b
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' (Proxy p
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' :: 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') = (t x -> s' x -> (:*:) t s' x
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: s' x
s') (t x -> (:*:) t s' x) -> f (t x) -> f ((:*:) t s' x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> g n -> (a -> f b) -> s x -> f (t x)
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' :: 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 s x -> t' x -> (:*:) s t' x
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*:) (t' x -> (:*:) s t' x) -> f (t' x) -> f ((:*:) s t' x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Proxy n' -> (a -> f b) -> s' x -> f (t' x)
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 (Proxy n'
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 = Proxy N0
forall k (t :: k). Proxy t
Proxy
{-# INLINE proxyN0 #-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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