-- |
-- Module: Data.Tuple.Optics
-- Description: 'Lens'es for tuple types.
--
-- This module defines 'Lens'es for the fields of tuple types.  These are
-- overloaded using the 'Field1' to 'Field9' typeclasses, so that '_1' can be
-- used as a 'Lens' for the first field of a tuple with any number of fields (up
-- to the maximum supported tuple size, which is currently 9).  For example:
--
-- >>> view _1 ('a','b','c')
-- 'a'
--
-- >>> set _3 True ('a','b','c')
-- ('a','b',True)
--
-- If a single-constructor datatype has a 'Generic' instance, the corresponding
-- @FieldN@ instances can be defined using their default methods:
--
-- >>> :set -XDeriveGeneric
-- >>> data T a = MkT Int a deriving (Generic, Show)
-- >>> instance Field1 (T a) (T a) Int Int
-- >>> instance Field2 (T a) (T b) a b
--
-- >>> set _2 'x' (MkT 1 False)
-- MkT 1 'x'
--
{-# LANGUAGE UndecidableInstances   #-}
module Data.Tuple.Optics
  (
  -- * Tuples
    Field1(..)
  , Field2(..)
  , Field3(..)
  , Field4(..)
  , Field5(..)
  , Field6(..)
  , Field7(..)
  , Field8(..)
  , Field9(..)
  -- * Strict variations
  , _1', _2', _3', _4', _5', _6', _7', _8', _9'
  ) where

import Data.Functor.Identity
import Data.Functor.Product
import Data.Kind
import Data.Proxy
import GHC.Generics ((:*:)(..), Generic(..), K1, M1, U1)

import GHC.Generics.Optics
import Optics.Lens
import Optics.Optic

-- | 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,2) & _1 .~ "hello"
  -- ("hello",2)
  --
  -- >>> traverseOf _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 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 s t n a b (f :: * -> *).
(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] _1 #-}

instance Field1 (Identity a) (Identity b) a b where
  _1 :: Lens (Identity a) (Identity b) a b
_1 = LensVL (Identity a) (Identity b) a b
-> Lens (Identity a) (Identity b) a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (Identity a) (Identity b) a b
 -> Lens (Identity a) (Identity b) a b)
-> LensVL (Identity a) (Identity b) a b
-> Lens (Identity a) (Identity b) a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (Identity 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
  {-# INLINE[1] _1 #-}

instance Field1 (Product f g a) (Product f' g a) (f a) (f' a) where
  _1 :: Lens (Product f g a) (Product f' g a) (f a) (f' a)
_1 = LensVL (Product f g a) (Product f' g a) (f a) (f' a)
-> Lens (Product f g a) (Product f' g a) (f a) (f' a)
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (Product f g a) (Product f' g a) (f a) (f' a)
 -> Lens (Product f g a) (Product f' g a) (f a) (f' a))
-> LensVL (Product f g a) (Product f' g a) (f a) (f' a)
-> Lens (Product f g a) (Product f' g a) (f a) (f' a)
forall a b. (a -> b) -> a -> b
$ \f a -> f (f' a)
f ~(Pair 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
  {-# INLINE[1] _1 #-}

instance Field1 ((f :*: g) p) ((f' :*: g) p) (f p) (f' p) where
  _1 :: Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
_1 = LensVL ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
-> Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
 -> Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p))
-> LensVL ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
-> Lens ((:*:) f g p) ((:*:) f' g p) (f p) (f' p)
forall a b. (a -> b) -> a -> b
$ \f p -> f (f' p)
f ~(l :*: 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
  {-# INLINE[1] _1 #-}

instance Field1 (a,b) (a',b) a a' where
  _1 :: Lens (a, b) (a', b) a a'
_1 = LensVL (a, b) (a', b) a a' -> Lens (a, b) (a', b) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b) (a', b) a a' -> Lens (a, b) (a', b) a a')
-> LensVL (a, b) (a', b) a a' -> Lens (a, b) (a', b) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,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] _1 #-}

instance Field1 (a,b,c) (a',b,c) a a' where
  _1 :: Lens (a, b, c) (a', b, c) a a'
_1 = LensVL (a, b, c) (a', b, c) a a' -> Lens (a, b, c) (a', b, c) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c) (a', b, c) a a'
 -> Lens (a, b, c) (a', b, c) a a')
-> LensVL (a, b, c) (a', b, c) a a'
-> Lens (a, b, c) (a', b, c) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,b,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] _1 #-}

instance Field1 (a,b,c,d) (a',b,c,d) a a' where
  _1 :: Lens (a, b, c, d) (a', b, c, d) a a'
_1 = LensVL (a, b, c, d) (a', b, c, d) a a'
-> Lens (a, b, c, d) (a', b, c, d) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d) (a', b, c, d) a a'
 -> Lens (a, b, c, d) (a', b, c, d) a a')
-> LensVL (a, b, c, d) (a', b, c, d) a a'
-> Lens (a, b, c, d) (a', b, c, d) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,b,c,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] _1 #-}

instance Field1 (a,b,c,d,e) (a',b,c,d,e) a a' where
  _1 :: Lens (a, b, c, d, e) (a', b, c, d, e) a a'
_1 = LensVL (a, b, c, d, e) (a', b, c, d, e) a a'
-> Lens (a, b, c, d, e) (a', b, c, d, e) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e) (a', b, c, d, e) a a'
 -> Lens (a, b, c, d, e) (a', b, c, d, e) a a')
-> LensVL (a, b, c, d, e) (a', b, c, d, e) a a'
-> Lens (a, b, c, d, e) (a', b, c, d, e) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,b,c,d,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] _1 #-}

instance Field1 (a,b,c,d,e,f) (a',b,c,d,e,f) a a' where
  _1 :: Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
_1 = LensVL (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
-> Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
 -> Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a')
-> LensVL (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
-> Lens (a, b, c, d, e, f) (a', b, c, d, e, f) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,b,c,d,e,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] _1 #-}

instance Field1 (a,b,c,d,e,f,g) (a',b,c,d,e,f,g) a a' where
  _1 :: Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
_1 = LensVL (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
-> Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
 -> Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a')
-> LensVL (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
-> Lens (a, b, c, d, e, f, g) (a', b, c, d, e, f, g) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,b,c,d,e,f,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] _1 #-}

instance Field1 (a,b,c,d,e,f,g,h) (a',b,c,d,e,f,g,h) a a' where
  _1 :: Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
_1 = LensVL (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
-> Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
 -> Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a')
-> LensVL (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
-> Lens (a, b, c, d, e, f, g, h) (a', b, c, d, e, f, g, h) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,b,c,d,e,f,g,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] _1 #-}

instance Field1 (a,b,c,d,e,f,g,h,i) (a',b,c,d,e,f,g,h,i) a a' where
  _1 :: Lens (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
_1 = LensVL
  (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a', b, c, d, e, f, g, h, i) a a'
forall a b. (a -> b) -> a -> b
$ \a -> f a'
k ~(a,b,c,d,e,f,g,h,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] _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)
  --
  -- >>> traverseOf _2 print (1,2)
  -- 2
  -- (1,())
  _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N1
proxyN1
  {-# INLINE[1] _2 #-}

instance Field2 (Product f g a) (Product f g' a) (g a) (g' a) where
  _2 :: Lens (Product f g a) (Product f g' a) (g a) (g' a)
_2 = LensVL (Product f g a) (Product f g' a) (g a) (g' a)
-> Lens (Product f g a) (Product f g' a) (g a) (g' a)
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (Product f g a) (Product f g' a) (g a) (g' a)
 -> Lens (Product f g a) (Product f g' a) (g a) (g' a))
-> LensVL (Product f g a) (Product f g' a) (g a) (g' a)
-> Lens (Product f g a) (Product f g' a) (g a) (g' a)
forall a b. (a -> b) -> a -> b
$ \g a -> f (g' a)
f ~(Pair 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
  {-# INLINE[1] _2 #-}

instance Field2 ((f :*: g) p) ((f :*: g') p) (g p) (g' p) where
  _2 :: Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
_2 = LensVL ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
-> Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
 -> Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p))
-> LensVL ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
-> Lens ((:*:) f g p) ((:*:) f g' p) (g p) (g' p)
forall a b. (a -> b) -> a -> b
$ \g p -> f (g' p)
f ~(l :*: 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
  {-# INLINE[1] _2 #-}

instance Field2 (a,b) (a,b') b b' where
  _2 :: Lens (a, b) (a, b') b b'
_2 = LensVL (a, b) (a, b') b b' -> Lens (a, b) (a, b') b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b) (a, b') b b' -> Lens (a, b) (a, b') b b')
-> LensVL (a, b) (a, b') b b' -> Lens (a, b) (a, b') b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,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[1] _2 #-}

instance Field2 (a,b,c) (a,b',c) b b' where
  _2 :: Lens (a, b, c) (a, b', c) b b'
_2 = LensVL (a, b, c) (a, b', c) b b' -> Lens (a, b, c) (a, b', c) b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c) (a, b', c) b b'
 -> Lens (a, b, c) (a, b', c) b b')
-> LensVL (a, b, c) (a, b', c) b b'
-> Lens (a, b, c) (a, b', c) b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,b,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[1] _2 #-}

instance Field2 (a,b,c,d) (a,b',c,d) b b' where
  _2 :: Lens (a, b, c, d) (a, b', c, d) b b'
_2 = LensVL (a, b, c, d) (a, b', c, d) b b'
-> Lens (a, b, c, d) (a, b', c, d) b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d) (a, b', c, d) b b'
 -> Lens (a, b, c, d) (a, b', c, d) b b')
-> LensVL (a, b, c, d) (a, b', c, d) b b'
-> Lens (a, b, c, d) (a, b', c, d) b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,b,c,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[1] _2 #-}

instance Field2 (a,b,c,d,e) (a,b',c,d,e) b b' where
  _2 :: Lens (a, b, c, d, e) (a, b', c, d, e) b b'
_2 = LensVL (a, b, c, d, e) (a, b', c, d, e) b b'
-> Lens (a, b, c, d, e) (a, b', c, d, e) b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e) (a, b', c, d, e) b b'
 -> Lens (a, b, c, d, e) (a, b', c, d, e) b b')
-> LensVL (a, b, c, d, e) (a, b', c, d, e) b b'
-> Lens (a, b, c, d, e) (a, b', c, d, e) b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,b,c,d,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[1] _2 #-}

instance Field2 (a,b,c,d,e,f) (a,b',c,d,e,f) b b' where
  _2 :: Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
_2 = LensVL (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
-> Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
 -> Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b')
-> LensVL (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
-> Lens (a, b, c, d, e, f) (a, b', c, d, e, f) b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,b,c,d,e,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[1] _2 #-}

instance Field2 (a,b,c,d,e,f,g) (a,b',c,d,e,f,g) b b' where
  _2 :: Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
_2 = LensVL (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
-> Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
 -> Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b')
-> LensVL (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
-> Lens (a, b, c, d, e, f, g) (a, b', c, d, e, f, g) b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,b,c,d,e,f,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[1] _2 #-}

instance Field2 (a,b,c,d,e,f,g,h) (a,b',c,d,e,f,g,h) b b' where
  _2 :: Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
_2 = LensVL (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
-> Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
 -> Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b')
-> LensVL (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
-> Lens (a, b, c, d, e, f, g, h) (a, b', c, d, e, f, g, h) b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,b,c,d,e,f,g,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[1] _2 #-}

instance Field2 (a,b,c,d,e,f,g,h,i) (a,b',c,d,e,f,g,h,i) b b' where
  _2 :: Lens (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
_2 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b', c, d, e, f, g, h, i) b b'
forall a b. (a -> b) -> a -> b
$ \b -> f b'
k ~(a,b,c,d,e,f,g,h,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[1] _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N2
proxyN2
  {-# INLINE[1] _3 #-}

instance Field3 (a,b,c) (a,b,c') c c' where
  _3 :: Lens (a, b, c) (a, b, c') c c'
_3 = LensVL (a, b, c) (a, b, c') c c' -> Lens (a, b, c) (a, b, c') c c'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c) (a, b, c') c c'
 -> Lens (a, b, c) (a, b, c') c c')
-> LensVL (a, b, c) (a, b, c') c c'
-> Lens (a, b, c) (a, b, c') c c'
forall a b. (a -> b) -> a -> b
$ \c -> f c'
k ~(a,b,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[1] _3 #-}

instance Field3 (a,b,c,d) (a,b,c',d) c c' where
  _3 :: Lens (a, b, c, d) (a, b, c', d) c c'
_3 = LensVL (a, b, c, d) (a, b, c', d) c c'
-> Lens (a, b, c, d) (a, b, c', d) c c'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d) (a, b, c', d) c c'
 -> Lens (a, b, c, d) (a, b, c', d) c c')
-> LensVL (a, b, c, d) (a, b, c', d) c c'
-> Lens (a, b, c, d) (a, b, c', d) c c'
forall a b. (a -> b) -> a -> b
$ \c -> f c'
k ~(a,b,c,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[1] _3 #-}

instance Field3 (a,b,c,d,e) (a,b,c',d,e) c c' where
  _3 :: Lens (a, b, c, d, e) (a, b, c', d, e) c c'
_3 = LensVL (a, b, c, d, e) (a, b, c', d, e) c c'
-> Lens (a, b, c, d, e) (a, b, c', d, e) c c'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e) (a, b, c', d, e) c c'
 -> Lens (a, b, c, d, e) (a, b, c', d, e) c c')
-> LensVL (a, b, c, d, e) (a, b, c', d, e) c c'
-> Lens (a, b, c, d, e) (a, b, c', d, e) c c'
forall a b. (a -> b) -> a -> b
$ \c -> f c'
k ~(a,b,c,d,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[1] _3 #-}

instance Field3 (a,b,c,d,e,f) (a,b,c',d,e,f) c c' where
  _3 :: Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
_3 = LensVL (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
-> Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
 -> Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c')
-> LensVL (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
-> Lens (a, b, c, d, e, f) (a, b, c', d, e, f) c c'
forall a b. (a -> b) -> a -> b
$ \c -> f c'
k ~(a,b,c,d,e,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[1] _3 #-}

instance Field3 (a,b,c,d,e,f,g) (a,b,c',d,e,f,g) c c' where
  _3 :: Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
_3 = LensVL (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
-> Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
 -> Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c')
-> LensVL (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
-> Lens (a, b, c, d, e, f, g) (a, b, c', d, e, f, g) c c'
forall a b. (a -> b) -> a -> b
$ \c -> f c'
k ~(a,b,c,d,e,f,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[1] _3 #-}

instance Field3 (a,b,c,d,e,f,g,h) (a,b,c',d,e,f,g,h) c c' where
  _3 :: Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
_3 = LensVL (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
 -> Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c')
-> LensVL (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c', d, e, f, g, h) c c'
forall a b. (a -> b) -> a -> b
$ \c -> f c'
k ~(a,b,c,d,e,f,g,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[1] _3 #-}

instance Field3 (a,b,c,d,e,f,g,h,i) (a,b,c',d,e,f,g,h,i) c c' where
  _3 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
_3 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c', d, e, f, g, h, i) c c'
forall a b. (a -> b) -> a -> b
$ \c -> f c'
k ~(a,b,c,d,e,f,g,h,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[1] _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N3
proxyN3
  {-# INLINE[1] _4 #-}

instance Field4 (a,b,c,d) (a,b,c,d') d d' where
  _4 :: Lens (a, b, c, d) (a, b, c, d') d d'
_4 = LensVL (a, b, c, d) (a, b, c, d') d d'
-> Lens (a, b, c, d) (a, b, c, d') d d'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d) (a, b, c, d') d d'
 -> Lens (a, b, c, d) (a, b, c, d') d d')
-> LensVL (a, b, c, d) (a, b, c, d') d d'
-> Lens (a, b, c, d) (a, b, c, d') d d'
forall a b. (a -> b) -> a -> b
$ \d -> f d'
k ~(a,b,c,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[1] _4 #-}

instance Field4 (a,b,c,d,e) (a,b,c,d',e) d d' where
  _4 :: Lens (a, b, c, d, e) (a, b, c, d', e) d d'
_4 = LensVL (a, b, c, d, e) (a, b, c, d', e) d d'
-> Lens (a, b, c, d, e) (a, b, c, d', e) d d'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e) (a, b, c, d', e) d d'
 -> Lens (a, b, c, d, e) (a, b, c, d', e) d d')
-> LensVL (a, b, c, d, e) (a, b, c, d', e) d d'
-> Lens (a, b, c, d, e) (a, b, c, d', e) d d'
forall a b. (a -> b) -> a -> b
$ \d -> f d'
k ~(a,b,c,d,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[1] _4 #-}

instance Field4 (a,b,c,d,e,f) (a,b,c,d',e,f) d d' where
  _4 :: Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
_4 = LensVL (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
-> Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
 -> Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d')
-> LensVL (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
-> Lens (a, b, c, d, e, f) (a, b, c, d', e, f) d d'
forall a b. (a -> b) -> a -> b
$ \d -> f d'
k ~(a,b,c,d,e,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[1] _4 #-}

instance Field4 (a,b,c,d,e,f,g) (a,b,c,d',e,f,g) d d' where
  _4 :: Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
_4 = LensVL (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
 -> Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d')
-> LensVL (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d', e, f, g) d d'
forall a b. (a -> b) -> a -> b
$ \d -> f d'
k ~(a,b,c,d,e,f,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[1] _4 #-}

instance Field4 (a,b,c,d,e,f,g,h) (a,b,c,d',e,f,g,h) d d' where
  _4 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
_4 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
 -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d')
-> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d', e, f, g, h) d d'
forall a b. (a -> b) -> a -> b
$ \d -> f d'
k ~(a,b,c,d,e,f,g,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[1] _4 #-}

instance Field4 (a,b,c,d,e,f,g,h,i) (a,b,c,d',e,f,g,h,i) d d' where
  _4 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
_4 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d', e, f, g, h, i) d d'
forall a b. (a -> b) -> a -> b
$ \d -> f d'
k ~(a,b,c,d,e,f,g,h,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[1] _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N4
proxyN4
  {-# INLINE[1] _5 #-}

instance Field5 (a,b,c,d,e) (a,b,c,d,e') e e' where
  _5 :: Lens (a, b, c, d, e) (a, b, c, d, e') e e'
_5 = LensVL (a, b, c, d, e) (a, b, c, d, e') e e'
-> Lens (a, b, c, d, e) (a, b, c, d, e') e e'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e) (a, b, c, d, e') e e'
 -> Lens (a, b, c, d, e) (a, b, c, d, e') e e')
-> LensVL (a, b, c, d, e) (a, b, c, d, e') e e'
-> Lens (a, b, c, d, e) (a, b, c, d, e') e e'
forall a b. (a -> b) -> a -> b
$ \e -> f e'
k ~(a,b,c,d,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[1] _5 #-}

instance Field5 (a,b,c,d,e,f) (a,b,c,d,e',f) e e' where
  _5 :: Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
_5 = LensVL (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
-> Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
 -> Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e')
-> LensVL (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
-> Lens (a, b, c, d, e, f) (a, b, c, d, e', f) e e'
forall a b. (a -> b) -> a -> b
$ \e -> f e'
k ~(a,b,c,d,e,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[1] _5 #-}

instance Field5 (a,b,c,d,e,f,g) (a,b,c,d,e',f,g) e e' where
  _5 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
_5 = LensVL (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
 -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e')
-> LensVL (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d, e', f, g) e e'
forall a b. (a -> b) -> a -> b
$ \e -> f e'
k ~(a,b,c,d,e,f,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[1] _5 #-}

instance Field5 (a,b,c,d,e,f,g,h) (a,b,c,d,e',f,g,h) e e' where
  _5 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
_5 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
 -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e')
-> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e', f, g, h) e e'
forall a b. (a -> b) -> a -> b
$ \e -> f e'
k ~(a,b,c,d,e,f,g,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[1] _5 #-}

instance Field5 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e',f,g,h,i) e e' where
  _5 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
_5 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e', f, g, h, i) e e'
forall a b. (a -> b) -> a -> b
$ \e -> f e'
k ~(a,b,c,d,e,f,g,h,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[1] _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N5
proxyN5
  {-# INLINE[1] _6 #-}

instance Field6 (a,b,c,d,e,f) (a,b,c,d,e,f') f f' where
  _6 :: Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
_6 = LensVL (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
-> Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
 -> Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f')
-> LensVL (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
-> Lens (a, b, c, d, e, f) (a, b, c, d, e, f') f f'
forall a b. (a -> b) -> a -> b
$ \f -> f f'
k ~(a,b,c,d,e,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[1] _6 #-}

instance Field6 (a,b,c,d,e,f,g) (a,b,c,d,e,f',g) f f' where
  _6 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
_6 = LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
 -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f')
-> LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f', g) f f'
forall a b. (a -> b) -> a -> b
$ \f -> f f'
k ~(a,b,c,d,e,f,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[1] _6 #-}

instance Field6 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f',g,h) f f' where
  _6 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
_6 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
 -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f')
-> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f', g, h) f f'
forall a b. (a -> b) -> a -> b
$ \f -> f f'
k ~(a,b,c,d,e,f,g,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[1] _6 #-}

instance Field6 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f',g,h,i) f f' where
  _6 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
_6 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f', g, h, i) f f'
forall a b. (a -> b) -> a -> b
$ \f -> f f'
k ~(a,b,c,d,e,f,g,h,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[1] _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N6
proxyN6
  {-# INLINE[1] _7 #-}

instance Field7 (a,b,c,d,e,f,g) (a,b,c,d,e,f,g') g g' where
  _7 :: Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
_7 = LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
 -> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g')
-> LensVL (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
-> Lens (a, b, c, d, e, f, g) (a, b, c, d, e, f, g') g g'
forall a b. (a -> b) -> a -> b
$ \g -> f g'
k ~(a,b,c,d,e,f,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[1] _7 #-}

instance Field7 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f,g',h) g g' where
  _7 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
_7 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
 -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g')
-> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g', h) g g'
forall a b. (a -> b) -> a -> b
$ \g -> f g'
k ~(a,b,c,d,e,f,g,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[1] _7 #-}

instance Field7 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g',h,i) g g' where
  _7 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
_7 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g', h, i) g g'
forall a b. (a -> b) -> a -> b
$ \g -> f g'
k ~(a,b,c,d,e,f,g,h,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[1] _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N7
proxyN7
  {-# INLINE[1] _8 #-}

instance Field8 (a,b,c,d,e,f,g,h) (a,b,c,d,e,f,g,h') h h' where
  _8 :: Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
_8 = LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
 -> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h')
-> LensVL (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
-> Lens (a, b, c, d, e, f, g, h) (a, b, c, d, e, f, g, h') h h'
forall a b. (a -> b) -> a -> b
$ \h -> f h'
k ~(a,b,c,d,e,f,g,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[1] _8 #-}

instance Field8 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g,h',i) h h' where
  _8 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
_8 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h', i) h h'
forall a b. (a -> b) -> a -> b
$ \h -> f h'
k ~(a,b,c,d,e,f,g,h,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[1] _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 s t n a b (f :: * -> *).
(Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) =>
f n -> Lens s t a b
ix Proxy N8
proxyN8
  {-# INLINE[1] _9 #-}

instance Field9 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g,h,i') i i' where
  _9 :: Lens (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
_9 = LensVL
  (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL
   (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
 -> Lens
      (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i')
-> LensVL
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
-> Lens
     (a, b, c, d, e, f, g, h, i) (a, b, c, d, e, f, g, h, i') i i'
forall a b. (a -> b) -> a -> b
$ \i -> f i'
k ~(a,b,c,d,e,f,g,h,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[1] _9 #-}

-- Strict versions of the _1 .. _9 operations

-- | Strict version of '_1'
_1' :: Field1 s t a b => Lens s t a b
_1' :: Lens s t a b
_1' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field1 s t a b => Lens s t a b
_1
{-# INLINE _1' #-}

-- | Strict version of '_2'
_2' :: Field2 s t a b => Lens s t a b
_2' :: Lens s t a b
_2' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field2 s t a b => Lens s t a b
_2
{-# INLINE _2' #-}

-- | Strict version of '_3'
_3' :: Field3 s t a b => Lens s t a b
_3' :: Lens s t a b
_3' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field3 s t a b => Lens s t a b
_3
{-# INLINE _3' #-}

-- | Strict version of '_4'
_4' :: Field4 s t a b => Lens s t a b
_4' :: Lens s t a b
_4' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field4 s t a b => Lens s t a b
_4
{-# INLINE _4' #-}

-- | Strict version of '_5'
_5' :: Field5 s t a b => Lens s t a b
_5' :: Lens s t a b
_5' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field5 s t a b => Lens s t a b
_5
{-# INLINE _5' #-}

-- | Strict version of '_6'
_6' :: Field6 s t a b => Lens s t a b
_6' :: Lens s t a b
_6' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field6 s t a b => Lens s t a b
_6
{-# INLINE _6' #-}

-- | Strict version of '_7'
_7' :: Field7 s t a b => Lens s t a b
_7' :: Lens s t a b
_7' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field7 s t a b => Lens s t a b
_7
{-# INLINE _7' #-}

-- | Strict version of '_8'
_8' :: Field8 s t a b => Lens s t a b
_8' :: Lens s t a b
_8' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field8 s t a b => Lens s t a b
_8
{-# INLINE _8' #-}

-- | Strict version of '_9'
_9' :: Field9 s t a b => Lens s t a b
_9' :: Lens s t a b
_9' = Lens s t s t
forall a b. Lens a b a b
equality' Lens s t s t -> Lens s t a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Lens s t a b
forall s t a b. Field9 s t a b => Lens s t a b
_9
{-# INLINE _9' #-}

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 = Optic An_Iso NoIx s t (Rep s Any) (Rep t Any)
forall a b c. (Generic a, Generic b) => Iso a b (Rep a c) (Rep b c)
generic Optic An_Iso NoIx s t (Rep s Any) (Rep t Any)
-> Optic A_Lens NoIx (Rep s Any) (Rep t Any) a b -> Lens s t a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% f n -> Optic A_Lens NoIx (Rep s Any) (Rep t Any) a b
forall n (s :: * -> *) (t :: * -> *) a b (f :: * -> *) x.
GIxed n s t a b =>
f n -> Lens (s x) (t x) a b
gix f n
n
{-# INLINE ix #-}

-- TODO: this can be replaced by generic-optics position
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
_ = Optic An_Iso NoIx (K1 i a x) (K1 i b x) a b
-> Lens (K1 i a x) (K1 i b x) a b
forall destKind srcKind (is :: [*]) s t a b.
Is srcKind destKind =>
Optic srcKind is s t a b -> Optic destKind is s t a b
castOptic Optic An_Iso NoIx (K1 i a x) (K1 i b x) a b
forall k1 k2 i c (p :: k1) j d (q :: k2).
Iso (K1 i c p) (K1 j d q) c d
_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 = Iso (M1 i c s x) (M1 i c t x) (s x) (t x)
forall k1 k2 i (c :: Meta) (f :: k1 -> *) (p :: k1) j (d :: Meta)
       (g :: k2 -> *) (q :: k2).
Iso (M1 i c f p) (M1 j d g q) (f p) (g q)
_M1 Iso (M1 i c s x) (M1 i c t x) (s x) (t x)
-> Optic A_Lens NoIx (s x) (t x) a b
-> Lens (M1 i c s x) (M1 i c t x) a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% f n -> Optic A_Lens NoIx (s x) (t x) a b
forall n (s :: * -> *) (t :: * -> *) a b (f :: * -> *) x.
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 @p)
  {-# INLINE gix #-}

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 = Lens ((:*:) s s' x) ((:*:) t s' x) (s x) (t x)
forall s t a b. Field1 s t a b => Lens s t a b
_1 Lens ((:*:) s s' x) ((:*:) t s' x) (s x) (t x)
-> Optic A_Lens NoIx (s x) (t x) a b
-> Lens ((:*:) s s' x) ((:*:) t s' x) a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% g n -> Optic A_Lens NoIx (s x) (t x) a b
forall n (s :: * -> *) (t :: * -> *) a b (f :: * -> *) x.
GIxed n s t a b =>
f n -> Lens (s x) (t x) a b
gix g n
n
  {-# 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
_ = Lens ((:*:) s s' x) ((:*:) s t' x) (s' x) (t' x)
forall s t a b. Field2 s t a b => Lens s t a b
_2 Lens ((:*:) s s' x) ((:*:) s t' x) (s' x) (t' x)
-> Optic A_Lens NoIx (s' x) (t' x) a b
-> Lens ((:*:) s s' x) ((:*:) s t' x) a b
forall k m l (ks :: [*]) (is :: [*]) (js :: [*]) s t u v a b.
(Is k m, Is l m, m ~ Join k l, ks ~ Append is js) =>
Optic k is s t u v -> Optic l js u v a b -> Optic m ks s t a b
% Proxy n' -> Optic A_Lens NoIx (s' x) (t' x) a b
forall n (s :: * -> *) (t :: * -> *) a b (f :: * -> *) x.
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 @n')
  {-# 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

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 #-}

-- $setup
-- >>> import Optics.Core