{-# LANGUAGE ConstraintKinds       #-}
{-# LANGUAGE FlexibleContexts      #-}
{-# LANGUAGE FlexibleInstances     #-}
{-# LANGUAGE GADTs                 #-}
{-# LANGUAGE InstanceSigs          #-}
{-# LANGUAGE KindSignatures        #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE RankNTypes            #-}
{-# LANGUAGE ScopedTypeVariables   #-}
{-# LANGUAGE TypeApplications      #-}
{-# LANGUAGE UndecidableInstances  #-}

module Data.Record.Beam.Lenses (
    GLargeTableLenses
  , TableLensesI
  , GLargeDatabaseLenses
  ) where

import Data.Proxy
import Data.Record.Generic
import Data.Record.Generic.GHC
import Data.Record.Generic.Lens.VL
import Data.Record.Generic.Transform
import Database.Beam.Schema
import Lens.Micro hiding (to)

import qualified Data.Record.Generic.Rep as Rep
import qualified GHC.Generics            as GHC

import Data.Record.Beam.Interpretation

{-------------------------------------------------------------------------------
  Table lenses
-------------------------------------------------------------------------------}

type GLargeTableLenses outer tbl f = (
    Generic (tbl (Lenses outer f))
  , Generic (tbl Uninterpreted)
  , Generic (tbl f)
  , HasNormalForm (BeamInterpretation (Lenses outer f)) (tbl (Lenses outer f)) (tbl Uninterpreted)
  , HasNormalForm (BeamInterpretation f) (tbl f) (tbl Uninterpreted)
  , Constraints (tbl Uninterpreted) (TableLensesI outer f)
  )

instance GLargeTableLenses outer tbl f
      => GTableLenses outer f (ThroughLRGenerics (tbl f))
                              (ThroughLRGenerics (tbl (Lenses outer f))) where
  gTableLenses ::
       Proxy (ThroughLRGenerics (tbl f))
    -> Lens' (outer f) (ThroughLRGenerics (tbl f) p)
    -> ThroughLRGenerics (tbl (Lenses outer f)) ()
  gTableLenses :: forall p.
Proxy (ThroughLRGenerics (tbl f))
-> Lens' (outer f) (ThroughLRGenerics (tbl f) p)
-> ThroughLRGenerics (tbl (Lenses outer f)) ()
gTableLenses Proxy (ThroughLRGenerics (tbl f))
_ Lens' (outer f) (ThroughLRGenerics (tbl f) p)
lensToHere = tbl (Lenses outer f) -> ThroughLRGenerics (tbl (Lenses outer f)) ()
forall a p. a -> ThroughLRGenerics a p
WrapThroughLRGenerics (tbl (Lenses outer f)
 -> ThroughLRGenerics (tbl (Lenses outer f)) ())
-> tbl (Lenses outer f)
-> ThroughLRGenerics (tbl (Lenses outer f)) ()
forall a b. (a -> b) -> a -> b
$
      Rep I (tbl (Lenses outer f)) -> tbl (Lenses outer f)
forall a. Generic a => Rep I a -> a
to (Rep I (tbl (Lenses outer f)) -> tbl (Lenses outer f))
-> (Rep
      (Interpret (BeamInterpretation (Lenses outer f)))
      (tbl Uninterpreted)
    -> Rep I (tbl (Lenses outer f)))
-> Rep
     (Interpret (BeamInterpretation (Lenses outer f)))
     (tbl Uninterpreted)
-> tbl (Lenses outer f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy BeamInterpretation
-> Rep
     (Interpret (BeamInterpretation (Lenses outer f)))
     (tbl Uninterpreted)
-> Rep I (tbl (Lenses outer f))
forall {k} {dom} (d :: (k -> *) -> dom) (f :: k -> *)
       (x :: (k -> *) -> *).
HasNormalForm (d f) (x f) (x Uninterpreted) =>
Proxy d -> Rep (Interpret (d f)) (x Uninterpreted) -> Rep I (x f)
denormalize1 (forall {k} (t :: k). Proxy t
forall (t :: (* -> *) -> *). Proxy t
Proxy @BeamInterpretation) (Rep
   (Interpret (BeamInterpretation (Lenses outer f)))
   (tbl Uninterpreted)
 -> tbl (Lenses outer f))
-> Rep
     (Interpret (BeamInterpretation (Lenses outer f)))
     (tbl Uninterpreted)
-> tbl (Lenses outer f)
forall a b. (a -> b) -> a -> b
$
        Proxy (TableLensesI outer f)
-> (forall x.
    TableLensesI outer f x =>
    HKRecordLens BeamInterpretation f tbl x
    -> Interpret (BeamInterpretation (Lenses outer f)) x)
-> Rep (HKRecordLens BeamInterpretation f tbl) (tbl Uninterpreted)
-> Rep
     (Interpret (BeamInterpretation (Lenses outer f)))
     (tbl Uninterpreted)
forall a (c :: * -> Constraint) (f :: * -> *) (g :: * -> *).
(Generic a, Constraints a c) =>
Proxy c -> (forall x. c x => f x -> g x) -> Rep f a -> Rep g a
Rep.cmap
          (forall {k} (t :: k). Proxy t
forall (t :: * -> Constraint). Proxy t
Proxy @(TableLensesI outer f))
          HKRecordLens BeamInterpretation f tbl x
-> Interpret (BeamInterpretation (Lenses outer f)) x
forall x.
TableLensesI outer f x =>
HKRecordLens BeamInterpretation f tbl x
-> Interpret (BeamInterpretation (Lenses outer f)) x
aux
          (Proxy BeamInterpretation
-> Rep (HKRecordLens BeamInterpretation f tbl) (tbl Uninterpreted)
forall (d :: (* -> *) -> *) (tbl :: (* -> *) -> *) (f :: * -> *).
(Generic (tbl f), Generic (tbl Uninterpreted),
 HasNormalForm (d f) (tbl f) (tbl Uninterpreted)) =>
Proxy d -> Rep (HKRecordLens d f tbl) (tbl Uninterpreted)
lensesForHKRecord (forall {k} (t :: k). Proxy t
forall (t :: (* -> *) -> *). Proxy t
Proxy @BeamInterpretation))
    where
      aux ::
           TableLensesI outer f x
        => HKRecordLens BeamInterpretation f tbl x
        -> Interpret (BeamInterpretation (Lenses outer f)) x
      aux :: forall x.
TableLensesI outer f x =>
HKRecordLens BeamInterpretation f tbl x
-> Interpret (BeamInterpretation (Lenses outer f)) x
aux (HKRecordLens Lens' (tbl f) (Interpret (BeamInterpretation f) x)
l) = Lens' (outer f) (Interpreted (BeamInterpretation f) x)
-> Interpret (BeamInterpretation (Lenses outer f)) x
forall (outer :: (* -> *) -> *) (f :: * -> *) x.
TableLensesI outer f x =>
Lens' (outer f) (Interpreted (BeamInterpretation f) x)
-> Interpret (BeamInterpretation (Lenses outer f)) x
tableLensesI (Lens' (outer f) (Interpreted (BeamInterpretation f) x)
 -> Interpret (BeamInterpretation (Lenses outer f)) x)
-> Lens' (outer f) (Interpreted (BeamInterpretation f) x)
-> Interpret (BeamInterpretation (Lenses outer f)) x
forall a b. (a -> b) -> a -> b
$
            (ThroughLRGenerics (tbl f) p -> f (ThroughLRGenerics (tbl f) p))
-> outer f -> f (outer f)
Lens' (outer f) (ThroughLRGenerics (tbl f) p)
lensToHere
          ((ThroughLRGenerics (tbl f) p -> f (ThroughLRGenerics (tbl f) p))
 -> outer f -> f (outer f))
-> ((Interpreted (BeamInterpretation f) x
     -> f (Interpreted (BeamInterpretation f) x))
    -> ThroughLRGenerics (tbl f) p -> f (ThroughLRGenerics (tbl f) p))
-> (Interpreted (BeamInterpretation f) x
    -> f (Interpreted (BeamInterpretation f) x))
-> outer f
-> f (outer f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (tbl f -> f (tbl f))
-> ThroughLRGenerics (tbl f) p -> f (ThroughLRGenerics (tbl f) p)
forall a p (f :: * -> *).
Functor f =>
(a -> f a) -> ThroughLRGenerics a p -> f (ThroughLRGenerics a p)
unwrapThroughLRGenericsLens
          ((tbl f -> f (tbl f))
 -> ThroughLRGenerics (tbl f) p -> f (ThroughLRGenerics (tbl f) p))
-> ((Interpreted (BeamInterpretation f) x
     -> f (Interpreted (BeamInterpretation f) x))
    -> tbl f -> f (tbl f))
-> (Interpreted (BeamInterpretation f) x
    -> f (Interpreted (BeamInterpretation f) x))
-> ThroughLRGenerics (tbl f) p
-> f (ThroughLRGenerics (tbl f) p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Interpret (BeamInterpretation f) x
 -> f (Interpret (BeamInterpretation f) x))
-> tbl f -> f (tbl f)
Lens' (tbl f) (Interpret (BeamInterpretation f) x)
l
          ((Interpret (BeamInterpretation f) x
  -> f (Interpret (BeamInterpretation f) x))
 -> tbl f -> f (tbl f))
-> ((Interpreted (BeamInterpretation f) x
     -> f (Interpreted (BeamInterpretation f) x))
    -> Interpret (BeamInterpretation f) x
    -> f (Interpret (BeamInterpretation f) x))
-> (Interpreted (BeamInterpretation f) x
    -> f (Interpreted (BeamInterpretation f) x))
-> tbl f
-> f (tbl f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Interpreted (BeamInterpretation f) x
 -> f (Interpreted (BeamInterpretation f) x))
-> Interpret (BeamInterpretation f) x
-> f (Interpret (BeamInterpretation f) x)
forall d x (f :: * -> *).
Functor f =>
(Interpreted d x -> f (Interpreted d x))
-> Interpret d x -> f (Interpret d x)
interpretedLens

class TableLensesI outer f x where
  tableLensesI ::
       Lens' (outer f) (Interpreted (BeamInterpretation f) x)
    -> Interpret (BeamInterpretation (Lenses outer f)) x

-- GHC.Generic required by 'LensFor' constructor
instance GHC.Generic (outer f) => TableLensesI outer f (Uninterpreted x) where
  tableLensesI :: Lens'
  (outer f) (Interpreted (BeamInterpretation f) (Uninterpreted x))
-> Interpret
     (BeamInterpretation (Lenses outer f)) (Uninterpreted x)
tableLensesI Lens'
  (outer f) (Interpreted (BeamInterpretation f) (Uninterpreted x))
lensToHere = Interpreted (BeamInterpretation (Lenses outer f)) (Uninterpreted x)
-> Interpret
     (BeamInterpretation (Lenses outer f)) (Uninterpreted x)
forall {dom} (d :: dom) x. Interpreted d x -> Interpret d x
Interpret (Interpreted
   (BeamInterpretation (Lenses outer f)) (Uninterpreted x)
 -> Interpret
      (BeamInterpretation (Lenses outer f)) (Uninterpreted x))
-> Interpreted
     (BeamInterpretation (Lenses outer f)) (Uninterpreted x)
-> Interpret
     (BeamInterpretation (Lenses outer f)) (Uninterpreted x)
forall a b. (a -> b) -> a -> b
$ Lens' (outer f) (Columnar f x) -> LensFor (outer f) (Columnar f x)
forall t x. Generic t => Lens' t x -> LensFor t x
LensFor (Columnar f x -> f (Columnar f x)) -> outer f -> f (outer f)
(Interpreted (BeamInterpretation f) (Uninterpreted x)
 -> f (Interpreted (BeamInterpretation f) (Uninterpreted x)))
-> outer f -> f (outer f)
Lens' (outer f) (Columnar f x)
Lens'
  (outer f) (Interpreted (BeamInterpretation f) (Uninterpreted x))
lensToHere

-- We to through the GHC generics instance so that it works both when the
-- subsubtable uses GHC generics (typically, primary keys) and when it uses
-- LR generics (typically, mixins).
instance ( GHC.Generic (sub (Lenses outer f))
         , GHC.Generic (sub f)
         , GTableLenses outer f (GHC.Rep (sub f)) (GHC.Rep (sub (Lenses outer f)))
         )
      => TableLensesI outer f (sub Uninterpreted) where
  tableLensesI :: Lens'
  (outer f) (Interpreted (BeamInterpretation f) (sub Uninterpreted))
-> Interpret
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
tableLensesI Lens'
  (outer f) (Interpreted (BeamInterpretation f) (sub Uninterpreted))
lensToHere = Interpreted
  (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
-> Interpret
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
forall {dom} (d :: dom) x. Interpreted d x -> Interpret d x
Interpret (Interpreted
   (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
 -> Interpret
      (BeamInterpretation (Lenses outer f)) (sub Uninterpreted))
-> Interpreted
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
-> Interpret
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
forall a b. (a -> b) -> a -> b
$
      Rep
  (Interpreted
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted))
  ()
-> Interpreted
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
forall a x. Generic a => Rep a x -> a
forall x.
Rep
  (Interpreted
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted))
  x
-> Interpreted
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
GHC.to (Rep
   (Interpreted
      (BeamInterpretation (Lenses outer f)) (sub Uninterpreted))
   ()
 -> Interpreted
      (BeamInterpretation (Lenses outer f)) (sub Uninterpreted))
-> Rep
     (Interpreted
        (BeamInterpretation (Lenses outer f)) (sub Uninterpreted))
     ()
-> Interpreted
     (BeamInterpretation (Lenses outer f)) (sub Uninterpreted)
forall a b. (a -> b) -> a -> b
$ Proxy (Rep (sub f))
-> Lens' (outer f) (Rep (sub f) Any)
-> Rep (sub (Lenses outer f)) ()
forall p.
Proxy (Rep (sub f))
-> Lens' (outer f) (Rep (sub f) p) -> Rep (sub (Lenses outer f)) ()
forall {k} (t :: (* -> *) -> *) (m :: * -> *) (a :: k -> *)
       (lensType :: * -> *) (p :: k).
GTableLenses t m a lensType =>
Proxy a -> Lens' (t m) (a p) -> lensType ()
gTableLenses Proxy (Rep (sub f))
forall {k} (t :: k). Proxy t
Proxy ((sub f -> f (sub f)) -> outer f -> f (outer f)
(Interpreted (BeamInterpretation f) (sub Uninterpreted)
 -> f (Interpreted (BeamInterpretation f) (sub Uninterpreted)))
-> outer f -> f (outer f)
Lens'
  (outer f) (Interpreted (BeamInterpretation f) (sub Uninterpreted))
lensToHere ((sub f -> f (sub f)) -> outer f -> f (outer f))
-> ((Rep (sub f) Any -> f (Rep (sub f) Any)) -> sub f -> f (sub f))
-> (Rep (sub f) Any -> f (Rep (sub f) Any))
-> outer f
-> f (outer f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rep (sub f) Any -> f (Rep (sub f) Any)) -> sub f -> f (sub f)
forall a p. Generic a => Lens' a (Rep a p)
Lens' (sub f) (Rep (sub f) Any)
ghcGenericLens)

instance ( GHC.Generic (sub (Nullable (Lenses outer f)))
         , GHC.Generic (sub (Nullable f))
         , GTableLenses outer f (GHC.Rep (sub (Nullable f))) (GHC.Rep (sub (Nullable (Lenses outer f))))
         )
      => TableLensesI outer f (sub (Nullable Uninterpreted)) where
  tableLensesI :: Lens'
  (outer f)
  (Interpreted (BeamInterpretation f) (sub (Nullable Uninterpreted)))
-> Interpret
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted))
tableLensesI Lens'
  (outer f)
  (Interpreted (BeamInterpretation f) (sub (Nullable Uninterpreted)))
lensToHere = Interpreted
  (BeamInterpretation (Lenses outer f))
  (sub (Nullable Uninterpreted))
-> Interpret
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted))
forall {dom} (d :: dom) x. Interpreted d x -> Interpret d x
Interpret (Interpreted
   (BeamInterpretation (Lenses outer f))
   (sub (Nullable Uninterpreted))
 -> Interpret
      (BeamInterpretation (Lenses outer f))
      (sub (Nullable Uninterpreted)))
-> Interpreted
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted))
-> Interpret
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted))
forall a b. (a -> b) -> a -> b
$
      Rep
  (Interpreted
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted)))
  ()
-> Interpreted
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted))
forall a x. Generic a => Rep a x -> a
forall x.
Rep
  (Interpreted
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted)))
  x
-> Interpreted
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted))
GHC.to (Rep
   (Interpreted
      (BeamInterpretation (Lenses outer f))
      (sub (Nullable Uninterpreted)))
   ()
 -> Interpreted
      (BeamInterpretation (Lenses outer f))
      (sub (Nullable Uninterpreted)))
-> Rep
     (Interpreted
        (BeamInterpretation (Lenses outer f))
        (sub (Nullable Uninterpreted)))
     ()
-> Interpreted
     (BeamInterpretation (Lenses outer f))
     (sub (Nullable Uninterpreted))
forall a b. (a -> b) -> a -> b
$ Proxy (Rep (sub (Nullable f)))
-> Lens' (outer f) (Rep (sub (Nullable f)) Any)
-> Rep (sub (Nullable (Lenses outer f))) ()
forall p.
Proxy (Rep (sub (Nullable f)))
-> Lens' (outer f) (Rep (sub (Nullable f)) p)
-> Rep (sub (Nullable (Lenses outer f))) ()
forall {k} (t :: (* -> *) -> *) (m :: * -> *) (a :: k -> *)
       (lensType :: * -> *) (p :: k).
GTableLenses t m a lensType =>
Proxy a -> Lens' (t m) (a p) -> lensType ()
gTableLenses Proxy (Rep (sub (Nullable f)))
forall {k} (t :: k). Proxy t
Proxy ((sub (Nullable f) -> f (sub (Nullable f)))
-> outer f -> f (outer f)
(Interpreted (BeamInterpretation f) (sub (Nullable Uninterpreted))
 -> f (Interpreted
         (BeamInterpretation f) (sub (Nullable Uninterpreted))))
-> outer f -> f (outer f)
Lens'
  (outer f)
  (Interpreted (BeamInterpretation f) (sub (Nullable Uninterpreted)))
lensToHere ((sub (Nullable f) -> f (sub (Nullable f)))
 -> outer f -> f (outer f))
-> ((Rep (sub (Nullable f)) Any -> f (Rep (sub (Nullable f)) Any))
    -> sub (Nullable f) -> f (sub (Nullable f)))
-> (Rep (sub (Nullable f)) Any -> f (Rep (sub (Nullable f)) Any))
-> outer f
-> f (outer f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Rep (sub (Nullable f)) Any -> f (Rep (sub (Nullable f)) Any))
-> sub (Nullable f) -> f (sub (Nullable f))
forall a p. Generic a => Lens' a (Rep a p)
Lens' (sub (Nullable f)) (Rep (sub (Nullable f)) Any)
ghcGenericLens)

{-------------------------------------------------------------------------------
  DB lenses
-------------------------------------------------------------------------------}

type GLargeDatabaseLenses outer db f = (
    Generic (db (TableLens f outer))
  , Generic (db Uninterpreted)
  , Generic (db f)
  , HasNormalForm (DefaultInterpretation (TableLens f outer)) (db (TableLens f outer)) (db Uninterpreted)
  , HasNormalForm (DefaultInterpretation f) (db f) (db Uninterpreted)
  , Constraints (db Uninterpreted) (DbLensesI outer f)
  )

instance GLargeDatabaseLenses outer db f
      => GDatabaseLenses (outer f) (ThroughLRGenerics (db f))
                                   (ThroughLRGenerics (db (TableLens f outer))) where
  gDatabaseLenses ::
       Lens' (outer f) (ThroughLRGenerics (db f) p)
    -> ThroughLRGenerics (db (TableLens f outer)) ()
  gDatabaseLenses :: forall p.
Lens' (outer f) (ThroughLRGenerics (db f) p)
-> ThroughLRGenerics (db (TableLens f outer)) ()
gDatabaseLenses Lens' (outer f) (ThroughLRGenerics (db f) p)
lensToHere = db (TableLens f outer)
-> ThroughLRGenerics (db (TableLens f outer)) ()
forall a p. a -> ThroughLRGenerics a p
WrapThroughLRGenerics (db (TableLens f outer)
 -> ThroughLRGenerics (db (TableLens f outer)) ())
-> db (TableLens f outer)
-> ThroughLRGenerics (db (TableLens f outer)) ()
forall a b. (a -> b) -> a -> b
$
      Rep I (db (TableLens f outer)) -> db (TableLens f outer)
forall a. Generic a => Rep I a -> a
to (Rep I (db (TableLens f outer)) -> db (TableLens f outer))
-> (Rep
      (Interpret (DefaultInterpretation (TableLens f outer)))
      (db Uninterpreted)
    -> Rep I (db (TableLens f outer)))
-> Rep
     (Interpret (DefaultInterpretation (TableLens f outer)))
     (db Uninterpreted)
-> db (TableLens f outer)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy DefaultInterpretation
-> Rep
     (Interpret (DefaultInterpretation (TableLens f outer)))
     (db Uninterpreted)
-> Rep I (db (TableLens f outer))
forall {k} {dom} (d :: (k -> *) -> dom) (f :: k -> *)
       (x :: (k -> *) -> *).
HasNormalForm (d f) (x f) (x Uninterpreted) =>
Proxy d -> Rep (Interpret (d f)) (x Uninterpreted) -> Rep I (x f)
denormalize1 (forall {k} (t :: k). Proxy t
forall (t :: (* -> *) -> *). Proxy t
Proxy @(DefaultInterpretation)) (Rep
   (Interpret (DefaultInterpretation (TableLens f outer)))
   (db Uninterpreted)
 -> db (TableLens f outer))
-> Rep
     (Interpret (DefaultInterpretation (TableLens f outer)))
     (db Uninterpreted)
-> db (TableLens f outer)
forall a b. (a -> b) -> a -> b
$
        Proxy (DbLensesI outer f)
-> (forall x.
    DbLensesI outer f x =>
    HKRecordLens DefaultInterpretation f db x
    -> Interpret (DefaultInterpretation (TableLens f outer)) x)
-> Rep (HKRecordLens DefaultInterpretation f db) (db Uninterpreted)
-> Rep
     (Interpret (DefaultInterpretation (TableLens f outer)))
     (db Uninterpreted)
forall a (c :: * -> Constraint) (f :: * -> *) (g :: * -> *).
(Generic a, Constraints a c) =>
Proxy c -> (forall x. c x => f x -> g x) -> Rep f a -> Rep g a
Rep.cmap
          (forall {k} (t :: k). Proxy t
forall (t :: * -> Constraint). Proxy t
Proxy @(DbLensesI outer f))
          HKRecordLens DefaultInterpretation f db x
-> Interpret (DefaultInterpretation (TableLens f outer)) x
forall x.
DbLensesI outer f x =>
HKRecordLens DefaultInterpretation f db x
-> Interpret (DefaultInterpretation (TableLens f outer)) x
aux
          (Proxy DefaultInterpretation
-> Rep (HKRecordLens DefaultInterpretation f db) (db Uninterpreted)
forall (d :: (* -> *) -> *) (tbl :: (* -> *) -> *) (f :: * -> *).
(Generic (tbl f), Generic (tbl Uninterpreted),
 HasNormalForm (d f) (tbl f) (tbl Uninterpreted)) =>
Proxy d -> Rep (HKRecordLens d f tbl) (tbl Uninterpreted)
lensesForHKRecord (forall {k} (t :: k). Proxy t
forall (t :: (* -> *) -> *). Proxy t
Proxy @DefaultInterpretation))
    where
      aux ::
           DbLensesI outer f x
        => HKRecordLens DefaultInterpretation f db x
        -> Interpret (DefaultInterpretation (TableLens f outer)) x
      aux :: forall x.
DbLensesI outer f x =>
HKRecordLens DefaultInterpretation f db x
-> Interpret (DefaultInterpretation (TableLens f outer)) x
aux (HKRecordLens Lens' (db f) (Interpret (DefaultInterpretation f) x)
l) = Lens' (outer f) (Interpreted (DefaultInterpretation f) x)
-> Interpret (DefaultInterpretation (TableLens f outer)) x
forall (outer :: (* -> *) -> *) (f :: * -> *) x.
DbLensesI outer f x =>
Lens' (outer f) (Interpreted (DefaultInterpretation f) x)
-> Interpret (DefaultInterpretation (TableLens f outer)) x
dbLensesI (Lens' (outer f) (Interpreted (DefaultInterpretation f) x)
 -> Interpret (DefaultInterpretation (TableLens f outer)) x)
-> Lens' (outer f) (Interpreted (DefaultInterpretation f) x)
-> Interpret (DefaultInterpretation (TableLens f outer)) x
forall a b. (a -> b) -> a -> b
$
            (ThroughLRGenerics (db f) p -> f (ThroughLRGenerics (db f) p))
-> outer f -> f (outer f)
Lens' (outer f) (ThroughLRGenerics (db f) p)
lensToHere
          ((ThroughLRGenerics (db f) p -> f (ThroughLRGenerics (db f) p))
 -> outer f -> f (outer f))
-> ((Interpreted (DefaultInterpretation f) x
     -> f (Interpreted (DefaultInterpretation f) x))
    -> ThroughLRGenerics (db f) p -> f (ThroughLRGenerics (db f) p))
-> (Interpreted (DefaultInterpretation f) x
    -> f (Interpreted (DefaultInterpretation f) x))
-> outer f
-> f (outer f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (db f -> f (db f))
-> ThroughLRGenerics (db f) p -> f (ThroughLRGenerics (db f) p)
forall a p (f :: * -> *).
Functor f =>
(a -> f a) -> ThroughLRGenerics a p -> f (ThroughLRGenerics a p)
unwrapThroughLRGenericsLens
          ((db f -> f (db f))
 -> ThroughLRGenerics (db f) p -> f (ThroughLRGenerics (db f) p))
-> ((Interpreted (DefaultInterpretation f) x
     -> f (Interpreted (DefaultInterpretation f) x))
    -> db f -> f (db f))
-> (Interpreted (DefaultInterpretation f) x
    -> f (Interpreted (DefaultInterpretation f) x))
-> ThroughLRGenerics (db f) p
-> f (ThroughLRGenerics (db f) p)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Interpret (DefaultInterpretation f) x
 -> f (Interpret (DefaultInterpretation f) x))
-> db f -> f (db f)
Lens' (db f) (Interpret (DefaultInterpretation f) x)
l
          ((Interpret (DefaultInterpretation f) x
  -> f (Interpret (DefaultInterpretation f) x))
 -> db f -> f (db f))
-> ((Interpreted (DefaultInterpretation f) x
     -> f (Interpreted (DefaultInterpretation f) x))
    -> Interpret (DefaultInterpretation f) x
    -> f (Interpret (DefaultInterpretation f) x))
-> (Interpreted (DefaultInterpretation f) x
    -> f (Interpreted (DefaultInterpretation f) x))
-> db f
-> f (db f)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Interpreted (DefaultInterpretation f) x
 -> f (Interpreted (DefaultInterpretation f) x))
-> Interpret (DefaultInterpretation f) x
-> f (Interpret (DefaultInterpretation f) x)
forall d x (f :: * -> *).
Functor f =>
(Interpreted d x -> f (Interpreted d x))
-> Interpret d x -> f (Interpret d x)
interpretedLens

class DbLensesI outer f x where
  dbLensesI ::
       Lens' (outer f) (Interpreted (DefaultInterpretation f) x)
    -> Interpret (DefaultInterpretation (TableLens f outer)) x

instance DbLensesI db f (Uninterpreted (TableEntity tbl)) where
  dbLensesI :: Lens'
  (db f)
  (Interpreted
     (DefaultInterpretation f) (Uninterpreted (TableEntity tbl)))
-> Interpret
     (DefaultInterpretation (TableLens f db))
     (Uninterpreted (TableEntity tbl))
dbLensesI Lens'
  (db f)
  (Interpreted
     (DefaultInterpretation f) (Uninterpreted (TableEntity tbl)))
lensToHere = Interpreted
  (DefaultInterpretation (TableLens f db))
  (Uninterpreted (TableEntity tbl))
-> Interpret
     (DefaultInterpretation (TableLens f db))
     (Uninterpreted (TableEntity tbl))
forall {dom} (d :: dom) x. Interpreted d x -> Interpret d x
Interpret (Interpreted
   (DefaultInterpretation (TableLens f db))
   (Uninterpreted (TableEntity tbl))
 -> Interpret
      (DefaultInterpretation (TableLens f db))
      (Uninterpreted (TableEntity tbl)))
-> Interpreted
     (DefaultInterpretation (TableLens f db))
     (Uninterpreted (TableEntity tbl))
-> Interpret
     (DefaultInterpretation (TableLens f db))
     (Uninterpreted (TableEntity tbl))
forall a b. (a -> b) -> a -> b
$ Lens' (db f) (f (TableEntity tbl))
-> TableLens f db (TableEntity tbl)
forall k (f :: k -> *) (db :: (k -> *) -> *) (x :: k).
Lens' (db f) (f x) -> TableLens f db x
TableLens (f (TableEntity tbl) -> f (f (TableEntity tbl)))
-> db f -> f (db f)
(Interpreted
   (DefaultInterpretation f) (Uninterpreted (TableEntity tbl))
 -> f (Interpreted
         (DefaultInterpretation f) (Uninterpreted (TableEntity tbl))))
-> db f -> f (db f)
Lens' (db f) (f (TableEntity tbl))
Lens'
  (db f)
  (Interpreted
     (DefaultInterpretation f) (Uninterpreted (TableEntity tbl)))
lensToHere

{-------------------------------------------------------------------------------
  Auxiliary
-------------------------------------------------------------------------------}

ghcGenericLens :: GHC.Generic a => Lens' a (GHC.Rep a p)
ghcGenericLens :: forall a p. Generic a => Lens' a (Rep a p)
ghcGenericLens Rep a p -> f (Rep a p)
f a
x = Rep a p -> a
forall a x. Generic a => Rep a x -> a
forall x. Rep a x -> a
GHC.to (Rep a p -> a) -> f (Rep a p) -> f a
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Rep a p -> f (Rep a p)
f (a -> Rep a p
forall x. a -> Rep a x
forall a x. Generic a => a -> Rep a x
GHC.from a
x)

unwrapThroughLRGenericsLens :: Lens' (ThroughLRGenerics a p) a
unwrapThroughLRGenericsLens :: forall a p (f :: * -> *).
Functor f =>
(a -> f a) -> ThroughLRGenerics a p -> f (ThroughLRGenerics a p)
unwrapThroughLRGenericsLens a -> f a
f ThroughLRGenerics a p
x =
    a -> ThroughLRGenerics a p
forall a p. a -> ThroughLRGenerics a p
WrapThroughLRGenerics (a -> ThroughLRGenerics a p) -> f a -> f (ThroughLRGenerics a p)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a
f (ThroughLRGenerics a p -> a
forall a p. ThroughLRGenerics a p -> a
unwrapThroughLRGenerics ThroughLRGenerics a p
x)