{-# language DataKinds #-}
{-# language DeriveAnyClass #-}
{-# language DeriveGeneric #-}
{-# language DerivingStrategies #-}
{-# language DuplicateRecordFields #-}

{-# options_ghc -O0 #-}

module Rel8.Schema.Generic.Test
  ( module Rel8.Schema.Generic.Test
  )
where

-- base
import GHC.Generics ( Generic )
import Prelude

-- rel8
import Rel8.Schema.Column
import Rel8.Schema.Generic

-- text
import Data.Text ( Text )


data Table f = Table
  { forall (f :: * -> *). Table f -> Column f (Label "blah" Bool)
foo :: Column f (Label "blah" Bool)
  , forall (f :: * -> *). Table f -> Column f (Maybe Bool)
bar :: Column f (Maybe Bool)
  }
  deriving stock (forall x. Table f -> Rep (Table f) x)
-> (forall x. Rep (Table f) x -> Table f) -> Generic (Table f)
forall x. Rep (Table f) x -> Table f
forall x. Table f -> Rep (Table f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (Table f) x -> Table f
forall (f :: * -> *) x. Table f -> Rep (Table f) x
$cto :: forall (f :: * -> *) x. Rep (Table f) x -> Table f
$cfrom :: forall (f :: * -> *) x. Table f -> Rep (Table f) x
Generic
  deriving anyclass HTable (GRep Table)
HTable (GRep Table)
-> (GRep Table (Col Aggregate) -> Table Aggregate)
-> (Table Aggregate -> GRep Table (Col Aggregate))
-> (GRep Table (Col Expr) -> Table Expr)
-> (Table Expr -> GRep Table (Col Expr))
-> (GRep Table (Col Insert) -> Table Insert)
-> (Table Insert -> GRep Table (Col Insert))
-> (GRep Table (Col Identity) -> Table Identity)
-> (Table Identity -> GRep Table (Col Identity))
-> (GRep Table (Col Name) -> Table Name)
-> (Table Name -> GRep Table (Col Name))
-> Rel8able Table
GRep Table (Col Expr) -> Table Expr
GRep Table (Col Identity) -> Table Identity
GRep Table (Col Name) -> Table Name
GRep Table (Col Aggregate) -> Table Aggregate
GRep Table (Col Insert) -> Table Insert
Table Expr -> GRep Table (Col Expr)
Table Identity -> GRep Table (Col Identity)
Table Name -> GRep Table (Col Name)
Table Aggregate -> GRep Table (Col Aggregate)
Table Insert -> GRep Table (Col Insert)
forall (t :: KTable).
HTable (GRep t)
-> (GRep t (Col Aggregate) -> t Aggregate)
-> (t Aggregate -> GRep t (Col Aggregate))
-> (GRep t (Col Expr) -> t Expr)
-> (t Expr -> GRep t (Col Expr))
-> (GRep t (Col Insert) -> t Insert)
-> (t Insert -> GRep t (Col Insert))
-> (GRep t (Col Identity) -> t Identity)
-> (t Identity -> GRep t (Col Identity))
-> (GRep t (Col Name) -> t Name)
-> (t Name -> GRep t (Col Name))
-> Rel8able t
toNameColumns :: Table Name -> GRep Table (Col Name)
$ctoNameColumns :: Table Name -> GRep Table (Col Name)
fromNameColumns :: GRep Table (Col Name) -> Table Name
$cfromNameColumns :: GRep Table (Col Name) -> Table Name
toIdentityColumns :: Table Identity -> GRep Table (Col Identity)
$ctoIdentityColumns :: Table Identity -> GRep Table (Col Identity)
fromIdentityColumns :: GRep Table (Col Identity) -> Table Identity
$cfromIdentityColumns :: GRep Table (Col Identity) -> Table Identity
toInsertColumns :: Table Insert -> GRep Table (Col Insert)
$ctoInsertColumns :: Table Insert -> GRep Table (Col Insert)
fromInsertColumns :: GRep Table (Col Insert) -> Table Insert
$cfromInsertColumns :: GRep Table (Col Insert) -> Table Insert
toExprColumns :: Table Expr -> GRep Table (Col Expr)
$ctoExprColumns :: Table Expr -> GRep Table (Col Expr)
fromExprColumns :: GRep Table (Col Expr) -> Table Expr
$cfromExprColumns :: GRep Table (Col Expr) -> Table Expr
toAggregateColumns :: Table Aggregate -> GRep Table (Col Aggregate)
$ctoAggregateColumns :: Table Aggregate -> GRep Table (Col Aggregate)
fromAggregateColumns :: GRep Table (Col Aggregate) -> Table Aggregate
$cfromAggregateColumns :: GRep Table (Col Aggregate) -> Table Aggregate
Rel8able


data TablePair f = TablePair
  { forall (f :: * -> *). TablePair f -> Column f (Default Bool)
foo :: Column f (Default Bool)
  , forall (f :: * -> *). TablePair f -> (Column f Text, Column f Text)
bars :: (Column f Text, Column f Text)
  }
  deriving stock (forall x. TablePair f -> Rep (TablePair f) x)
-> (forall x. Rep (TablePair f) x -> TablePair f)
-> Generic (TablePair f)
forall x. Rep (TablePair f) x -> TablePair f
forall x. TablePair f -> Rep (TablePair f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (TablePair f) x -> TablePair f
forall (f :: * -> *) x. TablePair f -> Rep (TablePair f) x
$cto :: forall (f :: * -> *) x. Rep (TablePair f) x -> TablePair f
$cfrom :: forall (f :: * -> *) x. TablePair f -> Rep (TablePair f) x
Generic
  deriving anyclass HTable (GRep TablePair)
HTable (GRep TablePair)
-> (GRep TablePair (Col Aggregate) -> TablePair Aggregate)
-> (TablePair Aggregate -> GRep TablePair (Col Aggregate))
-> (GRep TablePair (Col Expr) -> TablePair Expr)
-> (TablePair Expr -> GRep TablePair (Col Expr))
-> (GRep TablePair (Col Insert) -> TablePair Insert)
-> (TablePair Insert -> GRep TablePair (Col Insert))
-> (GRep TablePair (Col Identity) -> TablePair Identity)
-> (TablePair Identity -> GRep TablePair (Col Identity))
-> (GRep TablePair (Col Name) -> TablePair Name)
-> (TablePair Name -> GRep TablePair (Col Name))
-> Rel8able TablePair
GRep TablePair (Col Expr) -> TablePair Expr
GRep TablePair (Col Identity) -> TablePair Identity
GRep TablePair (Col Name) -> TablePair Name
GRep TablePair (Col Aggregate) -> TablePair Aggregate
GRep TablePair (Col Insert) -> TablePair Insert
TablePair Expr -> GRep TablePair (Col Expr)
TablePair Identity -> GRep TablePair (Col Identity)
TablePair Name -> GRep TablePair (Col Name)
TablePair Aggregate -> GRep TablePair (Col Aggregate)
TablePair Insert -> GRep TablePair (Col Insert)
forall (t :: KTable).
HTable (GRep t)
-> (GRep t (Col Aggregate) -> t Aggregate)
-> (t Aggregate -> GRep t (Col Aggregate))
-> (GRep t (Col Expr) -> t Expr)
-> (t Expr -> GRep t (Col Expr))
-> (GRep t (Col Insert) -> t Insert)
-> (t Insert -> GRep t (Col Insert))
-> (GRep t (Col Identity) -> t Identity)
-> (t Identity -> GRep t (Col Identity))
-> (GRep t (Col Name) -> t Name)
-> (t Name -> GRep t (Col Name))
-> Rel8able t
toNameColumns :: TablePair Name -> GRep TablePair (Col Name)
$ctoNameColumns :: TablePair Name -> GRep TablePair (Col Name)
fromNameColumns :: GRep TablePair (Col Name) -> TablePair Name
$cfromNameColumns :: GRep TablePair (Col Name) -> TablePair Name
toIdentityColumns :: TablePair Identity -> GRep TablePair (Col Identity)
$ctoIdentityColumns :: TablePair Identity -> GRep TablePair (Col Identity)
fromIdentityColumns :: GRep TablePair (Col Identity) -> TablePair Identity
$cfromIdentityColumns :: GRep TablePair (Col Identity) -> TablePair Identity
toInsertColumns :: TablePair Insert -> GRep TablePair (Col Insert)
$ctoInsertColumns :: TablePair Insert -> GRep TablePair (Col Insert)
fromInsertColumns :: GRep TablePair (Col Insert) -> TablePair Insert
$cfromInsertColumns :: GRep TablePair (Col Insert) -> TablePair Insert
toExprColumns :: TablePair Expr -> GRep TablePair (Col Expr)
$ctoExprColumns :: TablePair Expr -> GRep TablePair (Col Expr)
fromExprColumns :: GRep TablePair (Col Expr) -> TablePair Expr
$cfromExprColumns :: GRep TablePair (Col Expr) -> TablePair Expr
toAggregateColumns :: TablePair Aggregate -> GRep TablePair (Col Aggregate)
$ctoAggregateColumns :: TablePair Aggregate -> GRep TablePair (Col Aggregate)
fromAggregateColumns :: GRep TablePair (Col Aggregate) -> TablePair Aggregate
$cfromAggregateColumns :: GRep TablePair (Col Aggregate) -> TablePair Aggregate
Rel8able


data TableMaybe f = TableMaybe
  { forall (f :: * -> *).
TableMaybe f -> Column f (Label "ABC" [Maybe Bool])
foo :: Column f (Label "ABC" [Maybe Bool])
  , forall (f :: * -> *).
TableMaybe f -> HMaybe f (TablePair f, TablePair f)
bars :: HMaybe f (TablePair f, TablePair f)
  }
  deriving stock (forall x. TableMaybe f -> Rep (TableMaybe f) x)
-> (forall x. Rep (TableMaybe f) x -> TableMaybe f)
-> Generic (TableMaybe f)
forall x. Rep (TableMaybe f) x -> TableMaybe f
forall x. TableMaybe f -> Rep (TableMaybe f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (TableMaybe f) x -> TableMaybe f
forall (f :: * -> *) x. TableMaybe f -> Rep (TableMaybe f) x
$cto :: forall (f :: * -> *) x. Rep (TableMaybe f) x -> TableMaybe f
$cfrom :: forall (f :: * -> *) x. TableMaybe f -> Rep (TableMaybe f) x
Generic
  deriving anyclass HTable (GRep TableMaybe)
HTable (GRep TableMaybe)
-> (GRep TableMaybe (Col Aggregate) -> TableMaybe Aggregate)
-> (TableMaybe Aggregate -> GRep TableMaybe (Col Aggregate))
-> (GRep TableMaybe (Col Expr) -> TableMaybe Expr)
-> (TableMaybe Expr -> GRep TableMaybe (Col Expr))
-> (GRep TableMaybe (Col Insert) -> TableMaybe Insert)
-> (TableMaybe Insert -> GRep TableMaybe (Col Insert))
-> (GRep TableMaybe (Col Identity) -> TableMaybe Identity)
-> (TableMaybe Identity -> GRep TableMaybe (Col Identity))
-> (GRep TableMaybe (Col Name) -> TableMaybe Name)
-> (TableMaybe Name -> GRep TableMaybe (Col Name))
-> Rel8able TableMaybe
GRep TableMaybe (Col Expr) -> TableMaybe Expr
GRep TableMaybe (Col Identity) -> TableMaybe Identity
GRep TableMaybe (Col Name) -> TableMaybe Name
GRep TableMaybe (Col Aggregate) -> TableMaybe Aggregate
GRep TableMaybe (Col Insert) -> TableMaybe Insert
TableMaybe Expr -> GRep TableMaybe (Col Expr)
TableMaybe Identity -> GRep TableMaybe (Col Identity)
TableMaybe Name -> GRep TableMaybe (Col Name)
TableMaybe Aggregate -> GRep TableMaybe (Col Aggregate)
TableMaybe Insert -> GRep TableMaybe (Col Insert)
forall (t :: KTable).
HTable (GRep t)
-> (GRep t (Col Aggregate) -> t Aggregate)
-> (t Aggregate -> GRep t (Col Aggregate))
-> (GRep t (Col Expr) -> t Expr)
-> (t Expr -> GRep t (Col Expr))
-> (GRep t (Col Insert) -> t Insert)
-> (t Insert -> GRep t (Col Insert))
-> (GRep t (Col Identity) -> t Identity)
-> (t Identity -> GRep t (Col Identity))
-> (GRep t (Col Name) -> t Name)
-> (t Name -> GRep t (Col Name))
-> Rel8able t
toNameColumns :: TableMaybe Name -> GRep TableMaybe (Col Name)
$ctoNameColumns :: TableMaybe Name -> GRep TableMaybe (Col Name)
fromNameColumns :: GRep TableMaybe (Col Name) -> TableMaybe Name
$cfromNameColumns :: GRep TableMaybe (Col Name) -> TableMaybe Name
toIdentityColumns :: TableMaybe Identity -> GRep TableMaybe (Col Identity)
$ctoIdentityColumns :: TableMaybe Identity -> GRep TableMaybe (Col Identity)
fromIdentityColumns :: GRep TableMaybe (Col Identity) -> TableMaybe Identity
$cfromIdentityColumns :: GRep TableMaybe (Col Identity) -> TableMaybe Identity
toInsertColumns :: TableMaybe Insert -> GRep TableMaybe (Col Insert)
$ctoInsertColumns :: TableMaybe Insert -> GRep TableMaybe (Col Insert)
fromInsertColumns :: GRep TableMaybe (Col Insert) -> TableMaybe Insert
$cfromInsertColumns :: GRep TableMaybe (Col Insert) -> TableMaybe Insert
toExprColumns :: TableMaybe Expr -> GRep TableMaybe (Col Expr)
$ctoExprColumns :: TableMaybe Expr -> GRep TableMaybe (Col Expr)
fromExprColumns :: GRep TableMaybe (Col Expr) -> TableMaybe Expr
$cfromExprColumns :: GRep TableMaybe (Col Expr) -> TableMaybe Expr
toAggregateColumns :: TableMaybe Aggregate -> GRep TableMaybe (Col Aggregate)
$ctoAggregateColumns :: TableMaybe Aggregate -> GRep TableMaybe (Col Aggregate)
fromAggregateColumns :: GRep TableMaybe (Col Aggregate) -> TableMaybe Aggregate
$cfromAggregateColumns :: GRep TableMaybe (Col Aggregate) -> TableMaybe Aggregate
Rel8able


data TableEither f = TableEither
  { forall (f :: * -> *). TableEither f -> Column f Bool
foo :: Column f Bool
  , forall (f :: * -> *).
TableEither f
-> HEither
     f
     (HMaybe f (TablePair f, TablePair f))
     (Column f (Label "XYZ" Char))
bars :: HEither f (HMaybe f (TablePair f, TablePair f)) (Column f (Label "XYZ" Char))
  }
  deriving stock (forall x. TableEither f -> Rep (TableEither f) x)
-> (forall x. Rep (TableEither f) x -> TableEither f)
-> Generic (TableEither f)
forall x. Rep (TableEither f) x -> TableEither f
forall x. TableEither f -> Rep (TableEither f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (TableEither f) x -> TableEither f
forall (f :: * -> *) x. TableEither f -> Rep (TableEither f) x
$cto :: forall (f :: * -> *) x. Rep (TableEither f) x -> TableEither f
$cfrom :: forall (f :: * -> *) x. TableEither f -> Rep (TableEither f) x
Generic
  deriving anyclass HTable (GRep TableEither)
HTable (GRep TableEither)
-> (GRep TableEither (Col Aggregate) -> TableEither Aggregate)
-> (TableEither Aggregate -> GRep TableEither (Col Aggregate))
-> (GRep TableEither (Col Expr) -> TableEither Expr)
-> (TableEither Expr -> GRep TableEither (Col Expr))
-> (GRep TableEither (Col Insert) -> TableEither Insert)
-> (TableEither Insert -> GRep TableEither (Col Insert))
-> (GRep TableEither (Col Identity) -> TableEither Identity)
-> (TableEither Identity -> GRep TableEither (Col Identity))
-> (GRep TableEither (Col Name) -> TableEither Name)
-> (TableEither Name -> GRep TableEither (Col Name))
-> Rel8able TableEither
GRep TableEither (Col Expr) -> TableEither Expr
GRep TableEither (Col Identity) -> TableEither Identity
GRep TableEither (Col Name) -> TableEither Name
GRep TableEither (Col Aggregate) -> TableEither Aggregate
GRep TableEither (Col Insert) -> TableEither Insert
TableEither Expr -> GRep TableEither (Col Expr)
TableEither Identity -> GRep TableEither (Col Identity)
TableEither Name -> GRep TableEither (Col Name)
TableEither Aggregate -> GRep TableEither (Col Aggregate)
TableEither Insert -> GRep TableEither (Col Insert)
forall (t :: KTable).
HTable (GRep t)
-> (GRep t (Col Aggregate) -> t Aggregate)
-> (t Aggregate -> GRep t (Col Aggregate))
-> (GRep t (Col Expr) -> t Expr)
-> (t Expr -> GRep t (Col Expr))
-> (GRep t (Col Insert) -> t Insert)
-> (t Insert -> GRep t (Col Insert))
-> (GRep t (Col Identity) -> t Identity)
-> (t Identity -> GRep t (Col Identity))
-> (GRep t (Col Name) -> t Name)
-> (t Name -> GRep t (Col Name))
-> Rel8able t
toNameColumns :: TableEither Name -> GRep TableEither (Col Name)
$ctoNameColumns :: TableEither Name -> GRep TableEither (Col Name)
fromNameColumns :: GRep TableEither (Col Name) -> TableEither Name
$cfromNameColumns :: GRep TableEither (Col Name) -> TableEither Name
toIdentityColumns :: TableEither Identity -> GRep TableEither (Col Identity)
$ctoIdentityColumns :: TableEither Identity -> GRep TableEither (Col Identity)
fromIdentityColumns :: GRep TableEither (Col Identity) -> TableEither Identity
$cfromIdentityColumns :: GRep TableEither (Col Identity) -> TableEither Identity
toInsertColumns :: TableEither Insert -> GRep TableEither (Col Insert)
$ctoInsertColumns :: TableEither Insert -> GRep TableEither (Col Insert)
fromInsertColumns :: GRep TableEither (Col Insert) -> TableEither Insert
$cfromInsertColumns :: GRep TableEither (Col Insert) -> TableEither Insert
toExprColumns :: TableEither Expr -> GRep TableEither (Col Expr)
$ctoExprColumns :: TableEither Expr -> GRep TableEither (Col Expr)
fromExprColumns :: GRep TableEither (Col Expr) -> TableEither Expr
$cfromExprColumns :: GRep TableEither (Col Expr) -> TableEither Expr
toAggregateColumns :: TableEither Aggregate -> GRep TableEither (Col Aggregate)
$ctoAggregateColumns :: TableEither Aggregate -> GRep TableEither (Col Aggregate)
fromAggregateColumns :: GRep TableEither (Col Aggregate) -> TableEither Aggregate
$cfromAggregateColumns :: GRep TableEither (Col Aggregate) -> TableEither Aggregate
Rel8able


data TableThese f = TableThese
  { forall (f :: * -> *). TableThese f -> Column f Bool
foo :: Column f Bool
  , forall (f :: * -> *).
TableThese f -> HThese f (TableMaybe f) (TableEither f)
bars :: HThese f (TableMaybe f) (TableEither f)
  }
  deriving stock (forall x. TableThese f -> Rep (TableThese f) x)
-> (forall x. Rep (TableThese f) x -> TableThese f)
-> Generic (TableThese f)
forall x. Rep (TableThese f) x -> TableThese f
forall x. TableThese f -> Rep (TableThese f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (TableThese f) x -> TableThese f
forall (f :: * -> *) x. TableThese f -> Rep (TableThese f) x
$cto :: forall (f :: * -> *) x. Rep (TableThese f) x -> TableThese f
$cfrom :: forall (f :: * -> *) x. TableThese f -> Rep (TableThese f) x
Generic
  deriving anyclass HTable (GRep TableThese)
HTable (GRep TableThese)
-> (GRep TableThese (Col Aggregate) -> TableThese Aggregate)
-> (TableThese Aggregate -> GRep TableThese (Col Aggregate))
-> (GRep TableThese (Col Expr) -> TableThese Expr)
-> (TableThese Expr -> GRep TableThese (Col Expr))
-> (GRep TableThese (Col Insert) -> TableThese Insert)
-> (TableThese Insert -> GRep TableThese (Col Insert))
-> (GRep TableThese (Col Identity) -> TableThese Identity)
-> (TableThese Identity -> GRep TableThese (Col Identity))
-> (GRep TableThese (Col Name) -> TableThese Name)
-> (TableThese Name -> GRep TableThese (Col Name))
-> Rel8able TableThese
GRep TableThese (Col Expr) -> TableThese Expr
GRep TableThese (Col Identity) -> TableThese Identity
GRep TableThese (Col Name) -> TableThese Name
GRep TableThese (Col Aggregate) -> TableThese Aggregate
GRep TableThese (Col Insert) -> TableThese Insert
TableThese Expr -> GRep TableThese (Col Expr)
TableThese Identity -> GRep TableThese (Col Identity)
TableThese Name -> GRep TableThese (Col Name)
TableThese Aggregate -> GRep TableThese (Col Aggregate)
TableThese Insert -> GRep TableThese (Col Insert)
forall (t :: KTable).
HTable (GRep t)
-> (GRep t (Col Aggregate) -> t Aggregate)
-> (t Aggregate -> GRep t (Col Aggregate))
-> (GRep t (Col Expr) -> t Expr)
-> (t Expr -> GRep t (Col Expr))
-> (GRep t (Col Insert) -> t Insert)
-> (t Insert -> GRep t (Col Insert))
-> (GRep t (Col Identity) -> t Identity)
-> (t Identity -> GRep t (Col Identity))
-> (GRep t (Col Name) -> t Name)
-> (t Name -> GRep t (Col Name))
-> Rel8able t
toNameColumns :: TableThese Name -> GRep TableThese (Col Name)
$ctoNameColumns :: TableThese Name -> GRep TableThese (Col Name)
fromNameColumns :: GRep TableThese (Col Name) -> TableThese Name
$cfromNameColumns :: GRep TableThese (Col Name) -> TableThese Name
toIdentityColumns :: TableThese Identity -> GRep TableThese (Col Identity)
$ctoIdentityColumns :: TableThese Identity -> GRep TableThese (Col Identity)
fromIdentityColumns :: GRep TableThese (Col Identity) -> TableThese Identity
$cfromIdentityColumns :: GRep TableThese (Col Identity) -> TableThese Identity
toInsertColumns :: TableThese Insert -> GRep TableThese (Col Insert)
$ctoInsertColumns :: TableThese Insert -> GRep TableThese (Col Insert)
fromInsertColumns :: GRep TableThese (Col Insert) -> TableThese Insert
$cfromInsertColumns :: GRep TableThese (Col Insert) -> TableThese Insert
toExprColumns :: TableThese Expr -> GRep TableThese (Col Expr)
$ctoExprColumns :: TableThese Expr -> GRep TableThese (Col Expr)
fromExprColumns :: GRep TableThese (Col Expr) -> TableThese Expr
$cfromExprColumns :: GRep TableThese (Col Expr) -> TableThese Expr
toAggregateColumns :: TableThese Aggregate -> GRep TableThese (Col Aggregate)
$ctoAggregateColumns :: TableThese Aggregate -> GRep TableThese (Col Aggregate)
fromAggregateColumns :: GRep TableThese (Col Aggregate) -> TableThese Aggregate
$cfromAggregateColumns :: GRep TableThese (Col Aggregate) -> TableThese Aggregate
Rel8able


data TableList f = TableList
  { forall (f :: * -> *). TableList f -> Column f Bool
foo :: Column f Bool
  , forall (f :: * -> *). TableList f -> HList f (TableThese f)
bars :: HList f (TableThese f)
  }
  deriving stock (forall x. TableList f -> Rep (TableList f) x)
-> (forall x. Rep (TableList f) x -> TableList f)
-> Generic (TableList f)
forall x. Rep (TableList f) x -> TableList f
forall x. TableList f -> Rep (TableList f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (TableList f) x -> TableList f
forall (f :: * -> *) x. TableList f -> Rep (TableList f) x
$cto :: forall (f :: * -> *) x. Rep (TableList f) x -> TableList f
$cfrom :: forall (f :: * -> *) x. TableList f -> Rep (TableList f) x
Generic
  deriving anyclass HTable (GRep TableList)
HTable (GRep TableList)
-> (GRep TableList (Col Aggregate) -> TableList Aggregate)
-> (TableList Aggregate -> GRep TableList (Col Aggregate))
-> (GRep TableList (Col Expr) -> TableList Expr)
-> (TableList Expr -> GRep TableList (Col Expr))
-> (GRep TableList (Col Insert) -> TableList Insert)
-> (TableList Insert -> GRep TableList (Col Insert))
-> (GRep TableList (Col Identity) -> TableList Identity)
-> (TableList Identity -> GRep TableList (Col Identity))
-> (GRep TableList (Col Name) -> TableList Name)
-> (TableList Name -> GRep TableList (Col Name))
-> Rel8able TableList
GRep TableList (Col Expr) -> TableList Expr
GRep TableList (Col Identity) -> TableList Identity
GRep TableList (Col Name) -> TableList Name
GRep TableList (Col Aggregate) -> TableList Aggregate
GRep TableList (Col Insert) -> TableList Insert
TableList Expr -> GRep TableList (Col Expr)
TableList Identity -> GRep TableList (Col Identity)
TableList Name -> GRep TableList (Col Name)
TableList Aggregate -> GRep TableList (Col Aggregate)
TableList Insert -> GRep TableList (Col Insert)
forall (t :: KTable).
HTable (GRep t)
-> (GRep t (Col Aggregate) -> t Aggregate)
-> (t Aggregate -> GRep t (Col Aggregate))
-> (GRep t (Col Expr) -> t Expr)
-> (t Expr -> GRep t (Col Expr))
-> (GRep t (Col Insert) -> t Insert)
-> (t Insert -> GRep t (Col Insert))
-> (GRep t (Col Identity) -> t Identity)
-> (t Identity -> GRep t (Col Identity))
-> (GRep t (Col Name) -> t Name)
-> (t Name -> GRep t (Col Name))
-> Rel8able t
toNameColumns :: TableList Name -> GRep TableList (Col Name)
$ctoNameColumns :: TableList Name -> GRep TableList (Col Name)
fromNameColumns :: GRep TableList (Col Name) -> TableList Name
$cfromNameColumns :: GRep TableList (Col Name) -> TableList Name
toIdentityColumns :: TableList Identity -> GRep TableList (Col Identity)
$ctoIdentityColumns :: TableList Identity -> GRep TableList (Col Identity)
fromIdentityColumns :: GRep TableList (Col Identity) -> TableList Identity
$cfromIdentityColumns :: GRep TableList (Col Identity) -> TableList Identity
toInsertColumns :: TableList Insert -> GRep TableList (Col Insert)
$ctoInsertColumns :: TableList Insert -> GRep TableList (Col Insert)
fromInsertColumns :: GRep TableList (Col Insert) -> TableList Insert
$cfromInsertColumns :: GRep TableList (Col Insert) -> TableList Insert
toExprColumns :: TableList Expr -> GRep TableList (Col Expr)
$ctoExprColumns :: TableList Expr -> GRep TableList (Col Expr)
fromExprColumns :: GRep TableList (Col Expr) -> TableList Expr
$cfromExprColumns :: GRep TableList (Col Expr) -> TableList Expr
toAggregateColumns :: TableList Aggregate -> GRep TableList (Col Aggregate)
$ctoAggregateColumns :: TableList Aggregate -> GRep TableList (Col Aggregate)
fromAggregateColumns :: GRep TableList (Col Aggregate) -> TableList Aggregate
$cfromAggregateColumns :: GRep TableList (Col Aggregate) -> TableList Aggregate
Rel8able


data TableNonEmpty f = TableNonEmpty
  { forall (f :: * -> *). TableNonEmpty f -> Column f Bool
foo :: Column f Bool
  , forall (f :: * -> *). TableNonEmpty f -> HNonEmpty f (TableList f)
bars :: HNonEmpty f (TableList f)
  }
  deriving stock (forall x. TableNonEmpty f -> Rep (TableNonEmpty f) x)
-> (forall x. Rep (TableNonEmpty f) x -> TableNonEmpty f)
-> Generic (TableNonEmpty f)
forall x. Rep (TableNonEmpty f) x -> TableNonEmpty f
forall x. TableNonEmpty f -> Rep (TableNonEmpty f) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall (f :: * -> *) x. Rep (TableNonEmpty f) x -> TableNonEmpty f
forall (f :: * -> *) x. TableNonEmpty f -> Rep (TableNonEmpty f) x
$cto :: forall (f :: * -> *) x. Rep (TableNonEmpty f) x -> TableNonEmpty f
$cfrom :: forall (f :: * -> *) x. TableNonEmpty f -> Rep (TableNonEmpty f) x
Generic
  deriving anyclass HTable (GRep TableNonEmpty)
HTable (GRep TableNonEmpty)
-> (GRep TableNonEmpty (Col Aggregate) -> TableNonEmpty Aggregate)
-> (TableNonEmpty Aggregate -> GRep TableNonEmpty (Col Aggregate))
-> (GRep TableNonEmpty (Col Expr) -> TableNonEmpty Expr)
-> (TableNonEmpty Expr -> GRep TableNonEmpty (Col Expr))
-> (GRep TableNonEmpty (Col Insert) -> TableNonEmpty Insert)
-> (TableNonEmpty Insert -> GRep TableNonEmpty (Col Insert))
-> (GRep TableNonEmpty (Col Identity) -> TableNonEmpty Identity)
-> (TableNonEmpty Identity -> GRep TableNonEmpty (Col Identity))
-> (GRep TableNonEmpty (Col Name) -> TableNonEmpty Name)
-> (TableNonEmpty Name -> GRep TableNonEmpty (Col Name))
-> Rel8able TableNonEmpty
GRep TableNonEmpty (Col Expr) -> TableNonEmpty Expr
GRep TableNonEmpty (Col Identity) -> TableNonEmpty Identity
GRep TableNonEmpty (Col Name) -> TableNonEmpty Name
GRep TableNonEmpty (Col Aggregate) -> TableNonEmpty Aggregate
GRep TableNonEmpty (Col Insert) -> TableNonEmpty Insert
TableNonEmpty Expr -> GRep TableNonEmpty (Col Expr)
TableNonEmpty Identity -> GRep TableNonEmpty (Col Identity)
TableNonEmpty Name -> GRep TableNonEmpty (Col Name)
TableNonEmpty Aggregate -> GRep TableNonEmpty (Col Aggregate)
TableNonEmpty Insert -> GRep TableNonEmpty (Col Insert)
forall (t :: KTable).
HTable (GRep t)
-> (GRep t (Col Aggregate) -> t Aggregate)
-> (t Aggregate -> GRep t (Col Aggregate))
-> (GRep t (Col Expr) -> t Expr)
-> (t Expr -> GRep t (Col Expr))
-> (GRep t (Col Insert) -> t Insert)
-> (t Insert -> GRep t (Col Insert))
-> (GRep t (Col Identity) -> t Identity)
-> (t Identity -> GRep t (Col Identity))
-> (GRep t (Col Name) -> t Name)
-> (t Name -> GRep t (Col Name))
-> Rel8able t
toNameColumns :: TableNonEmpty Name -> GRep TableNonEmpty (Col Name)
$ctoNameColumns :: TableNonEmpty Name -> GRep TableNonEmpty (Col Name)
fromNameColumns :: GRep TableNonEmpty (Col Name) -> TableNonEmpty Name
$cfromNameColumns :: GRep TableNonEmpty (Col Name) -> TableNonEmpty Name
toIdentityColumns :: TableNonEmpty Identity -> GRep TableNonEmpty (Col Identity)
$ctoIdentityColumns :: TableNonEmpty Identity -> GRep TableNonEmpty (Col Identity)
fromIdentityColumns :: GRep TableNonEmpty (Col Identity) -> TableNonEmpty Identity
$cfromIdentityColumns :: GRep TableNonEmpty (Col Identity) -> TableNonEmpty Identity
toInsertColumns :: TableNonEmpty Insert -> GRep TableNonEmpty (Col Insert)
$ctoInsertColumns :: TableNonEmpty Insert -> GRep TableNonEmpty (Col Insert)
fromInsertColumns :: GRep TableNonEmpty (Col Insert) -> TableNonEmpty Insert
$cfromInsertColumns :: GRep TableNonEmpty (Col Insert) -> TableNonEmpty Insert
toExprColumns :: TableNonEmpty Expr -> GRep TableNonEmpty (Col Expr)
$ctoExprColumns :: TableNonEmpty Expr -> GRep TableNonEmpty (Col Expr)
fromExprColumns :: GRep TableNonEmpty (Col Expr) -> TableNonEmpty Expr
$cfromExprColumns :: GRep TableNonEmpty (Col Expr) -> TableNonEmpty Expr
toAggregateColumns :: TableNonEmpty Aggregate -> GRep TableNonEmpty (Col Aggregate)
$ctoAggregateColumns :: TableNonEmpty Aggregate -> GRep TableNonEmpty (Col Aggregate)
fromAggregateColumns :: GRep TableNonEmpty (Col Aggregate) -> TableNonEmpty Aggregate
$cfromAggregateColumns :: GRep TableNonEmpty (Col Aggregate) -> TableNonEmpty Aggregate
Rel8able