From f8c083960e40cf43767787f1a9d5fd144af059d9 Mon Sep 17 00:00:00 2001 From: Oliver Charles Date: Fri, 18 Jun 2021 20:59:10 +0100 Subject: [PATCH 1/9] Doc tweaks --- docs/tutorial.rst | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/docs/tutorial.rst b/docs/tutorial.rst index 9a1520a8..888ad716 100644 --- a/docs/tutorial.rst +++ b/docs/tutorial.rst @@ -22,7 +22,7 @@ imports throughout this guide:: {-# language TypeApplications #-} {-# language TypeFamilies #-} - import Prelude + import Prelude hiding (filter) import Rel8 The Example Schema @@ -104,9 +104,9 @@ And similarly, the ``project`` table:: deriving stock (Generic) deriving anyclass (Rel8able) -To show query results in this documentation, we'll also need ``Show`` instances: -Unfortunately these definitions look a bit scary, but they are essentially just -``deriving (Show)``:: +To show query results in this documentation, we'll also need ``Show`` +instances: Unfortunately these definitions look a bit scary, but they are +essentially just ``deriving (Show)``:: deriving stock instance f ~ Result => Show (Author f) deriving stock instance f ~ Result => Show (Project f) @@ -161,11 +161,11 @@ can use ``namesFromLabelsWith``, which takes a transformation function. .. note:: You might be wondering why this information isn't in the definitions of - ``Author`` and ``Project`` above. Rel8 decouples ``TableSchema`` from the data - types themselves, as not all tables you define will necessarily have a schema. - For example, Rel8 allows you to define helper types to simplify the types of - queries - these tables only exist at query time, but there is no corresponding - base table. We'll see more on this idea later! + ``Author`` and ``Project`` above. Rel8 decouples ``TableSchema`` from the + data types themselves, as not all tables you define will necessarily have a + schema. For example, Rel8 allows you to define helper types to simplify the + types of queries - these tables only exist at query time, but there is no + corresponding base table. We'll see more on this idea later! With these table definitions, we can now start writing some queries! @@ -184,13 +184,14 @@ required knowledge. To start, we'll look at one of the simplest queries possible - a basic ``SELECT * FROM`` statement. To select all rows from a table, we use ``each``, and -supply a ``TableSchema``. So to select all ``project`` rows, we can write:: + supply a ``TableSchema``. So to select all ``project`` rows, we can write:: >>> :t each projectSchema each projectSchema :: Query (Project Expr) Notice that ``each`` gives us a ``Query`` that yields ``Project Expr`` rows. To -see what this means, let's have a look at a single field of a ``Project Expr``:: +see what this means, let's have a look at a single field of a ``Project +Expr``:: >>> let aProjectExpr = undefined :: Project Expr >>> :t projectAuthorId aProjectExpr @@ -217,8 +218,8 @@ Haskell values. Studying ``projectAuthorId`` again, we have:: >>> :t projectAuthorId aProjectResult projectAuthorId aProjectResult :: AuthorId -Here ``Column Result AuthorId`` reduces to just ``AuthorId``, with no -wrappping type at all. +Here ``Column Result AuthorId`` reduces to just ``AuthorId``, with no wrappping +type at all. Putting this all together, we can run our first query:: @@ -273,9 +274,9 @@ returned rows. We could write:: where_ $ projectAuthorId project ==. authorId author return (project, author) -but doing this every time you need a join can obscure the meaning of the -query you're writing. A good practice is to introduce specialised functions -for the particular joins in your database. In our case, this would be:: +but doing this every time you need a join can obscure the meaning of the query +you're writing. A good practice is to introduce specialised functions for the +particular joins in your database. In our case, this would be:: projectsForAuthor :: Author Expr -> Query (Project Expr) projectsForAuthor a = each projectSchema >>= filter \p -> @@ -344,8 +345,8 @@ structures. Earlier we saw an example of returning authors with their projects, but the query didn't do a great job of describing the one-to-many relationship between authors and their projects. -Let's look again at a query that returns authors and their projects, and -focus on the /type/ of that query:: +Let's look again at a query that returns authors and their projects, and focus +on the /type/ of that query:: projectsForAuthor a = each projectSchema >>= filter \p -> projectAuthorId p ==. authorId a @@ -359,7 +360,6 @@ focus on the /type/ of that query:: select conn authorsAndProjects :: MonadIO m => m [(Author Result, Project Result)] - Our query gives us a single list of pairs of authors and projects. However, with our domain knowledge of the schema, this isn't a great type - what we'd rather have is a list of pairs of authors and /lists/ of projects. That is, From 40f250b7b4fca2f2bf7faf2e9f55c2cec6b1958f Mon Sep 17 00:00:00 2001 From: Oliver Charles Date: Fri, 5 Nov 2021 09:53:45 +0000 Subject: [PATCH 2/9] Add `Rel8.TH.deriveRel8able` --- rel8.cabal | 3 ++ src/Rel8/Generic/Rel8able.hs | 2 +- src/Rel8/TH.hs | 52 +++++++++++++++++++++++++++++ tests/Rel8/Generic/Rel8able/Test.hs | 7 ++-- 4 files changed, 61 insertions(+), 3 deletions(-) create mode 100644 src/Rel8/TH.hs diff --git a/rel8.cabal b/rel8.cabal index a5aa26c9..045f092e 100644 --- a/rel8.cabal +++ b/rel8.cabal @@ -43,6 +43,8 @@ library , scientific , semialign , semigroupoids + , template-haskell + , th-abstraction , text , these , time @@ -69,6 +71,7 @@ library Rel8.Expr.Text Rel8.Expr.Time Rel8.Tabulate + Rel8.TH other-modules: Rel8.Aggregate diff --git a/src/Rel8/Generic/Rel8able.hs b/src/Rel8/Generic/Rel8able.hs index 365c17cb..300bb213 100644 --- a/src/Rel8/Generic/Rel8able.hs +++ b/src/Rel8/Generic/Rel8able.hs @@ -16,7 +16,7 @@ {-# language UndecidableInstances #-} module Rel8.Generic.Rel8able - ( KRel8able, Rel8able + ( KRel8able, Rel8able(..) , Algebra , GRep , GColumns, gfromColumns, gtoColumns diff --git a/src/Rel8/TH.hs b/src/Rel8/TH.hs new file mode 100644 index 00000000..c3e1ec19 --- /dev/null +++ b/src/Rel8/TH.hs @@ -0,0 +1,52 @@ +{-# LANGUAGE TemplateHaskell #-} +{-# LANGUAGE NamedFieldPuns #-} +{-# LANGUAGE LambdaCase #-} +{-# LANGUAGE BlockArguments #-} +module Rel8.TH (deriveRel8able) where + +import Prelude (show, (.), pure, (<$>), Maybe (Nothing), ($), fail) +import Language.Haskell.TH (Name, Q, Dec, instanceD, cxt, appT, conT, funD, clause, normalB, tySynEqn, tySynInstD, reportWarning, Type (AppT), newName, conP, varP, mkName, nameBase) +import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (DatatypeInfo), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant) +import Rel8.Generic.Rel8able ( Rel8able(..) ) +import Rel8.Schema.Result (Result) +import Data.Foldable (for_, foldr) +import Rel8.Schema.HTable.Identity (HIdentity) +import Rel8.Schema.HTable.Product (HProduct) +import Language.Haskell.TH.Syntax (showName) +import Data.Traversable (for) + +deriveRel8able :: Name -> Q [Dec] +deriveRel8able name = do + DatatypeInfo{ datatypeCons = [ ConstructorInfo{ constructorFields = f1:fs, constructorVariant = RecordConstructor (fieldName1:fieldNames) } ]} <- reifyDatatype name + + for_ (f1:fs) (reportWarning . show) + + pure <$> instanceD (cxt []) (appT (conT ''Rel8able) (conT name)) + [ tySynInstD $ tySynEqn Nothing (appT (conT ''GColumns) (conT name)) $ + foldr + (appT . appT (conT ''HProduct) . appT (conT ''HIdentity) . unColumn) + (appT (conT ''HIdentity) (unColumn f1)) + fs + + , tySynInstD $ tySynEqn Nothing (appT (conT ''GFromExprs) (conT name)) $ + appT (conT name) (conT ''Result) + + , funD 'gfromColumns $ pure $ + clause [] (normalB [|undefined|]) [] + + , funD 'gtoColumns $ pure $ + clause [] (normalB [|undefined|]) [] + + , funD 'gfromResult $ pure do + name1 <- newName $ nameBase fieldName1 + names <- for fieldNames $ newName . nameBase + clause [varP name1] (normalB [|undefined|]) [] + + , funD 'gtoResult $ pure $ + clause [] (normalB [|undefined|]) [] + ] + + +unColumn :: Type -> Q Type +unColumn (AppT (AppT _Column _f) t) = pure t +unColumn _ = fail "Not a 'Column f' application" \ No newline at end of file diff --git a/tests/Rel8/Generic/Rel8able/Test.hs b/tests/Rel8/Generic/Rel8able/Test.hs index 7a8fc87c..d8a06312 100644 --- a/tests/Rel8/Generic/Rel8able/Test.hs +++ b/tests/Rel8/Generic/Rel8able/Test.hs @@ -6,6 +6,7 @@ {-# language FlexibleInstances #-} {-# language MultiParamTypeClasses #-} {-# language StandaloneKindSignatures #-} +{-# language TemplateHaskell #-} {-# language TypeFamilies #-} {-# language TypeOperators #-} {-# language UndecidableInstances #-} @@ -23,6 +24,7 @@ import Prelude -- rel8 import Rel8 +import Rel8.TH ( deriveRel8able ) -- text import Data.Text ( Text ) @@ -32,8 +34,9 @@ data TableTest f = TableTest { foo :: Column f Bool , bar :: Column f (Maybe Bool) } - deriving stock Generic - deriving anyclass Rel8able + + +deriveRel8able ''TableTest data TablePair f = TablePair From 9b91a4a719ceac6ecca7f97de1a2f628de781842 Mon Sep 17 00:00:00 2001 From: Oliver Charles Date: Sat, 6 Nov 2021 09:02:17 +0000 Subject: [PATCH 3/9] WIP --- src/Rel8/TH.hs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Rel8/TH.hs b/src/Rel8/TH.hs index c3e1ec19..8f951955 100644 --- a/src/Rel8/TH.hs +++ b/src/Rel8/TH.hs @@ -40,7 +40,7 @@ deriveRel8able name = do , funD 'gfromResult $ pure do name1 <- newName $ nameBase fieldName1 names <- for fieldNames $ newName . nameBase - clause [varP name1] (normalB [|undefined|]) [] + clause [varP name1] (normalB [| undefined |]) [] , funD 'gtoResult $ pure $ clause [] (normalB [|undefined|]) [] From 628c64cd5e02a8a94163d1e75b2378f46111fc22 Mon Sep 17 00:00:00 2001 From: Oliver Charles Date: Sat, 6 Nov 2021 13:58:39 +0000 Subject: [PATCH 4/9] WIP --- src/Rel8/TH.hs | 42 +++++++++++++++++++++++++++--------------- 1 file changed, 27 insertions(+), 15 deletions(-) diff --git a/src/Rel8/TH.hs b/src/Rel8/TH.hs index 8f951955..7ee70e27 100644 --- a/src/Rel8/TH.hs +++ b/src/Rel8/TH.hs @@ -2,29 +2,28 @@ {-# LANGUAGE NamedFieldPuns #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE BlockArguments #-} +{-# LANGUAGE ViewPatterns #-} module Rel8.TH (deriveRel8able) where -import Prelude (show, (.), pure, (<$>), Maybe (Nothing), ($), fail) -import Language.Haskell.TH (Name, Q, Dec, instanceD, cxt, appT, conT, funD, clause, normalB, tySynEqn, tySynInstD, reportWarning, Type (AppT), newName, conP, varP, mkName, nameBase) -import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (DatatypeInfo), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant) +import Prelude ((.), pure, (<$>), Maybe (Nothing), ($), fail, map) +import Language.Haskell.TH (Name, Q, Dec, instanceD, cxt, appT, conT, funD, clause, normalB, tySynEqn, tySynInstD, Type (AppT), newName, conP, varP, nameBase, conE, appE, varE, appsE) +import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (DatatypeInfo), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant, constructorName) import Rel8.Generic.Rel8able ( Rel8able(..) ) import Rel8.Schema.Result (Result) -import Data.Foldable (for_, foldr) -import Rel8.Schema.HTable.Identity (HIdentity) -import Rel8.Schema.HTable.Product (HProduct) -import Language.Haskell.TH.Syntax (showName) +import Data.Foldable (foldl') +import Rel8.Schema.HTable.Identity (HIdentity(HIdentity)) +import Rel8.Schema.HTable.Product (HProduct(HProduct)) import Data.Traversable (for) +import Data.Functor.Identity (Identity(Identity)) deriveRel8able :: Name -> Q [Dec] deriveRel8able name = do - DatatypeInfo{ datatypeCons = [ ConstructorInfo{ constructorFields = f1:fs, constructorVariant = RecordConstructor (fieldName1:fieldNames) } ]} <- reifyDatatype name - - for_ (f1:fs) (reportWarning . show) + DatatypeInfo{ datatypeCons = [ ConstructorInfo{ constructorName, constructorFields = f1:fs, constructorVariant = RecordConstructor (fieldName1:fieldNames) } ]} <- reifyDatatype name pure <$> instanceD (cxt []) (appT (conT ''Rel8able) (conT name)) [ tySynInstD $ tySynEqn Nothing (appT (conT ''GColumns) (conT name)) $ - foldr - (appT . appT (conT ''HProduct) . appT (conT ''HIdentity) . unColumn) + foldl' + (\e x -> appT (appT (conT ''HProduct) e) (appT (conT ''HIdentity) (unColumn x))) (appT (conT ''HIdentity) (unColumn f1)) fs @@ -40,10 +39,23 @@ deriveRel8able name = do , funD 'gfromResult $ pure do name1 <- newName $ nameBase fieldName1 names <- for fieldNames $ newName . nameBase - clause [varP name1] (normalB [| undefined |]) [] + clause + [foldl' (\pat n -> conP 'HProduct [pat, conP 'HIdentity [conP 'Identity [varP n]]]) + (conP 'HIdentity [conP 'Identity [varP name1]]) + names] + (normalB (appsE (conE constructorName : (varE <$> (name1:names))))) + [] - , funD 'gtoResult $ pure $ - clause [] (normalB [|undefined|]) [] + , funD 'gtoResult $ pure do + name1 <- newName $ nameBase fieldName1 + names <- for fieldNames $ newName . nameBase + clause + [conP constructorName (map varP (name1:names))] + (normalB $ + foldl' (\e n -> appE (appE (conE 'HProduct) e) (appE (conE 'HIdentity) (appE (conE 'Identity) (varE n)))) + (appE (conE 'HIdentity) (appE (conE 'Identity) (varE name1))) + names + ) [] ] From 4c9c72a6257b2615eefa57812f271468366cab00 Mon Sep 17 00:00:00 2001 From: Oliver Charles Date: Sun, 7 Nov 2021 13:22:22 +0000 Subject: [PATCH 5/9] Works with Column-only types --- src/Rel8/Generic/Rel8able.hs | 2 -- src/Rel8/TH.hs | 58 +++++++++++++++++++++++++++++++----- 2 files changed, 51 insertions(+), 9 deletions(-) diff --git a/src/Rel8/Generic/Rel8able.hs b/src/Rel8/Generic/Rel8able.hs index 300bb213..7be33b16 100644 --- a/src/Rel8/Generic/Rel8able.hs +++ b/src/Rel8/Generic/Rel8able.hs @@ -19,8 +19,6 @@ module Rel8.Generic.Rel8able ( KRel8able, Rel8able(..) , Algebra , GRep - , GColumns, gfromColumns, gtoColumns - , GFromExprs, gfromResult, gtoResult , TSerialize, serialize, deserialize ) where diff --git a/src/Rel8/TH.hs b/src/Rel8/TH.hs index 7ee70e27..54332198 100644 --- a/src/Rel8/TH.hs +++ b/src/Rel8/TH.hs @@ -5,8 +5,8 @@ {-# LANGUAGE ViewPatterns #-} module Rel8.TH (deriveRel8able) where -import Prelude ((.), pure, (<$>), Maybe (Nothing), ($), fail, map) -import Language.Haskell.TH (Name, Q, Dec, instanceD, cxt, appT, conT, funD, clause, normalB, tySynEqn, tySynInstD, Type (AppT), newName, conP, varP, nameBase, conE, appE, varE, appsE) +import Prelude ((.), pure, (<$>), Maybe (Nothing), ($), fail, map, uncurry, id) +import Language.Haskell.TH (Name, Q, Dec, instanceD, cxt, appT, conT, funD, clause, normalB, tySynEqn, tySynInstD, Type (AppT), newName, conP, varP, nameBase, conE, appE, varE, appsE, caseE, match) import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (DatatypeInfo), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant, constructorName) import Rel8.Generic.Rel8able ( Rel8able(..) ) import Rel8.Schema.Result (Result) @@ -14,7 +14,8 @@ import Data.Foldable (foldl') import Rel8.Schema.HTable.Identity (HIdentity(HIdentity)) import Rel8.Schema.HTable.Product (HProduct(HProduct)) import Data.Traversable (for) -import Data.Functor.Identity (Identity(Identity)) +import Data.Functor.Identity (Identity(Identity), runIdentity) +import Rel8.Kind.Context (SContext(..)) deriveRel8able :: Name -> Q [Dec] deriveRel8able name = do @@ -30,11 +31,54 @@ deriveRel8able name = do , tySynInstD $ tySynEqn Nothing (appT (conT ''GFromExprs) (conT name)) $ appT (conT name) (conT ''Result) - , funD 'gfromColumns $ pure $ - clause [] (normalB [|undefined|]) [] + , funD 'gfromColumns $ pure do + contextName <- newName "context" + name1 <- newName $ nameBase fieldName1 + names <- for fieldNames $ newName . nameBase + let columns = + foldl' (\pat n -> conP 'HProduct [pat, conP 'HIdentity [varP n]]) + (conP 'HIdentity [varP name1]) + names + + cases = + caseE (varE contextName) $ + uncurry (mkCase (name1:names)) <$> + [ ('SAggregate, id) + , ('SExpr, id) + , ('SField, id) + , ('SName, id) + , ('SResult, appE (varE 'runIdentity)) + ] + where + mkCase ns context unpack = + match (conP context []) (normalB (appsE (conE constructorName:map (unpack . varE) ns))) [] + + clause [varP contextName, columns] (normalB cases) [] + + , funD 'gtoColumns $ pure do + name1 <- newName $ nameBase fieldName1 + names <- for fieldNames $ newName . nameBase + contextName <- newName "context" + + let mkColumns wrap = + foldl' (\e n -> appsE [conE 'HProduct, e, appsE [conE 'HIdentity, wrap (varE n)]]) + (appsE [conE 'HIdentity, wrap (varE name1)]) + names + + cases = + caseE (varE contextName) $ + uncurry mkCase <$> + [ ('SAggregate, id) + , ('SExpr, id) + , ('SField, id) + , ('SName, id) + , ('SResult, appE (conE 'Identity)) + ] + where + mkCase context pack = + match (conP context []) (normalB (mkColumns pack)) [] - , funD 'gtoColumns $ pure $ - clause [] (normalB [|undefined|]) [] + clause [varP contextName, conP constructorName (map varP (name1:names))] (normalB cases) [] , funD 'gfromResult $ pure do name1 <- newName $ nameBase fieldName1 From 828bf1c993348eaf60e41c57792c6d269f82aa5c Mon Sep 17 00:00:00 2001 From: Oliver Charles Date: Wed, 17 Nov 2021 10:37:08 +0000 Subject: [PATCH 6/9] WIP --- tests/Rel8/Generic/Rel8able/Test.hs | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/Rel8/Generic/Rel8able/Test.hs b/tests/Rel8/Generic/Rel8able/Test.hs index d8a06312..04c57a29 100644 --- a/tests/Rel8/Generic/Rel8able/Test.hs +++ b/tests/Rel8/Generic/Rel8able/Test.hs @@ -43,8 +43,9 @@ data TablePair f = TablePair { foo :: Column f Bool , bars :: (Column f Text, Column f Text) } - deriving stock Generic - deriving anyclass Rel8able + + +deriveRel8able ''TablePair data TableMaybe f = TableMaybe From a0dc68f73dabaf01d8c0e3ecb7107caf1212a115 Mon Sep 17 00:00:00 2001 From: Ollie Charles Date: Mon, 31 Jan 2022 13:03:13 +0000 Subject: [PATCH 7/9] Simplifications using quoting and splicing --- src/Rel8/TH.hs | 180 ++++++++++++++++++++++++------------------------- 1 file changed, 89 insertions(+), 91 deletions(-) diff --git a/src/Rel8/TH.hs b/src/Rel8/TH.hs index 54332198..74d17a31 100644 --- a/src/Rel8/TH.hs +++ b/src/Rel8/TH.hs @@ -3,106 +3,104 @@ {-# LANGUAGE LambdaCase #-} {-# LANGUAGE BlockArguments #-} {-# LANGUAGE ViewPatterns #-} +{-# LANGUAGE TypeFamilies #-} module Rel8.TH (deriveRel8able) where -import Prelude ((.), pure, (<$>), Maybe (Nothing), ($), fail, map, uncurry, id) -import Language.Haskell.TH (Name, Q, Dec, instanceD, cxt, appT, conT, funD, clause, normalB, tySynEqn, tySynInstD, Type (AppT), newName, conP, varP, nameBase, conE, appE, varE, appsE, caseE, match) -import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (DatatypeInfo), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant, constructorName) +import Prelude ((.), pure, (<$>), ($), fail, map, id, (==), (<>), show, last, error, otherwise) +import Language.Haskell.TH (Name, Q, Dec, conT, Type (AppT, ConT, VarT, TupleT), newName, conP, varP, nameBase, conE, varE, appsE, TyVarBndr(..), varT, tupleT) +import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (DatatypeInfo), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant, constructorName, datatypeVars) import Rel8.Generic.Rel8able ( Rel8able(..) ) import Rel8.Schema.Result (Result) -import Data.Foldable (foldl') +import Data.Foldable (foldl', toList ) import Rel8.Schema.HTable.Identity (HIdentity(HIdentity)) import Rel8.Schema.HTable.Product (HProduct(HProduct)) import Data.Traversable (for) import Data.Functor.Identity (Identity(Identity), runIdentity) import Rel8.Kind.Context (SContext(..)) +import Data.Functor ( (<&>) ) +import Data.List.NonEmpty ( NonEmpty( (:|) ) ) +import Rel8.Column ( Column ) +import Rel8.Expr ( Expr ) +import Rel8.Table ( Columns ) deriveRel8able :: Name -> Q [Dec] deriveRel8able name = do - DatatypeInfo{ datatypeCons = [ ConstructorInfo{ constructorName, constructorFields = f1:fs, constructorVariant = RecordConstructor (fieldName1:fieldNames) } ]} <- reifyDatatype name - - pure <$> instanceD (cxt []) (appT (conT ''Rel8able) (conT name)) - [ tySynInstD $ tySynEqn Nothing (appT (conT ''GColumns) (conT name)) $ - foldl' - (\e x -> appT (appT (conT ''HProduct) e) (appT (conT ''HIdentity) (unColumn x))) - (appT (conT ''HIdentity) (unColumn f1)) - fs - - , tySynInstD $ tySynEqn Nothing (appT (conT ''GFromExprs) (conT name)) $ - appT (conT name) (conT ''Result) - - , funD 'gfromColumns $ pure do - contextName <- newName "context" - name1 <- newName $ nameBase fieldName1 - names <- for fieldNames $ newName . nameBase - let columns = - foldl' (\pat n -> conP 'HProduct [pat, conP 'HIdentity [varP n]]) - (conP 'HIdentity [varP name1]) - names - - cases = - caseE (varE contextName) $ - uncurry (mkCase (name1:names)) <$> - [ ('SAggregate, id) - , ('SExpr, id) - , ('SField, id) - , ('SName, id) - , ('SResult, appE (varE 'runIdentity)) - ] - where - mkCase ns context unpack = - match (conP context []) (normalB (appsE (conE constructorName:map (unpack . varE) ns))) [] - - clause [varP contextName, columns] (normalB cases) [] - - , funD 'gtoColumns $ pure do - name1 <- newName $ nameBase fieldName1 - names <- for fieldNames $ newName . nameBase - contextName <- newName "context" - - let mkColumns wrap = - foldl' (\e n -> appsE [conE 'HProduct, e, appsE [conE 'HIdentity, wrap (varE n)]]) - (appsE [conE 'HIdentity, wrap (varE name1)]) - names - - cases = - caseE (varE contextName) $ - uncurry mkCase <$> - [ ('SAggregate, id) - , ('SExpr, id) - , ('SField, id) - , ('SName, id) - , ('SResult, appE (conE 'Identity)) - ] - where - mkCase context pack = - match (conP context []) (normalB (mkColumns pack)) [] - - clause [varP contextName, conP constructorName (map varP (name1:names))] (normalB cases) [] - - , funD 'gfromResult $ pure do - name1 <- newName $ nameBase fieldName1 - names <- for fieldNames $ newName . nameBase - clause - [foldl' (\pat n -> conP 'HProduct [pat, conP 'HIdentity [conP 'Identity [varP n]]]) - (conP 'HIdentity [conP 'Identity [varP name1]]) - names] - (normalB (appsE (conE constructorName : (varE <$> (name1:names))))) - [] - - , funD 'gtoResult $ pure do - name1 <- newName $ nameBase fieldName1 - names <- for fieldNames $ newName . nameBase - clause - [conP constructorName (map varP (name1:names))] - (normalB $ - foldl' (\e n -> appE (appE (conE 'HProduct) e) (appE (conE 'HIdentity) (appE (conE 'Identity) (varE n)))) - (appE (conE 'HIdentity) (appE (conE 'Identity) (varE name1))) - names - ) [] - ] - - -unColumn :: Type -> Q Type -unColumn (AppT (AppT _Column _f) t) = pure t -unColumn _ = fail "Not a 'Column f' application" \ No newline at end of file + DatatypeInfo{ datatypeVars = (last -> fBinder), datatypeCons = [ ConstructorInfo{ constructorName, constructorFields = f1:fs, constructorVariant = RecordConstructor (fieldName1:fieldNames) } ]} <- reifyDatatype name + + let f = case fBinder of + PlainTV a _ -> a + KindedTV a _ _ -> a + + contextName <- newName "context" + name1 <- newName $ nameBase fieldName1 + names <- for fieldNames $ newName . nameBase + + let allNames = name1 :| names + + let + unpackP = + foldl' + (\e n -> [p| HProduct $e (HIdentity $( varP n )) |]) + [p| HIdentity $( varP name1 ) |] + names + + unmk (x :| xs) = + foldl' + (\e n -> [| HProduct $e (HIdentity $n) |]) + [| HIdentity $x |] + xs + + mk xs = appsE (conE constructorName : toList xs) + + id + [d| instance Rel8able $( conT name ) where + type GColumns $( conT name) = + $( + foldl' + (\t x -> [t| HProduct $t $(unColumn f x) |]) + (unColumn f f1) + fs + ) + + type GFromExprs $( conT name ) = + $( conT name ) Result + + gfromColumns $( varP contextName ) $unpackP = + case $( varE contextName ) of + SAggregate -> $( mk $ varE <$> allNames ) + SExpr -> $( mk $ varE <$> allNames ) + SField -> $( mk $ varE <$> allNames ) + SName -> $( mk $ varE <$> allNames ) + SResult -> $( mk $ allNames <&> \x -> [| runIdentity $( varE x ) |] ) + + gtoColumns $(varP contextName) $( conP constructorName (map varP (name1:names)) ) = + case $( varE contextName ) of + SAggregate -> $( unmk $ varE <$> allNames ) + SExpr -> $( unmk $ varE <$> allNames ) + SField -> $( unmk $ varE <$> allNames ) + SName -> $( unmk $ varE <$> allNames ) + SResult -> $( unmk $ allNames <&> \x -> [| Identity $( varE x ) |] ) + + gfromResult $unpackP = + $( mk $ allNames <&> \x -> [| runIdentity $( varE x ) |] ) + + gtoResult $( conP constructorName (map varP (name1:names)) ) = + $( unmk $ allNames <&> \x -> [| Identity $( varE x ) |] ) + |] + + +unColumn :: Name -> Type -> Q Type +unColumn _ (AppT (AppT (ConT _Column) _f) t) | _Column == ''Column = [t| HIdentity $(pure t) |] +unColumn f t = [t| Columns $(instantiate t) |] + where + instantiate = \case + VarT v | v == f -> [t| Expr |] + | otherwise -> varT v + + AppT x y -> [t| $(instantiate x) $(instantiate y) |] + + TupleT n -> tupleT n + + ConT n -> conT n + + other -> error $ show other From 031c62c7027093a533774f32e3153a214aa7c86f Mon Sep 17 00:00:00 2001 From: Teo Camarasu Date: Fri, 21 Mar 2025 17:42:39 +0000 Subject: [PATCH 8/9] delete SAggregate this has been removed --- src/Rel8/TH.hs | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/Rel8/TH.hs b/src/Rel8/TH.hs index 74d17a31..1e43e198 100644 --- a/src/Rel8/TH.hs +++ b/src/Rel8/TH.hs @@ -67,7 +67,6 @@ deriveRel8able name = do gfromColumns $( varP contextName ) $unpackP = case $( varE contextName ) of - SAggregate -> $( mk $ varE <$> allNames ) SExpr -> $( mk $ varE <$> allNames ) SField -> $( mk $ varE <$> allNames ) SName -> $( mk $ varE <$> allNames ) @@ -75,7 +74,6 @@ deriveRel8able name = do gtoColumns $(varP contextName) $( conP constructorName (map varP (name1:names)) ) = case $( varE contextName ) of - SAggregate -> $( unmk $ varE <$> allNames ) SExpr -> $( unmk $ varE <$> allNames ) SField -> $( unmk $ varE <$> allNames ) SName -> $( unmk $ varE <$> allNames ) From 11e1f307932dc45556e5b3cb1dce0fae5a15ed44 Mon Sep 17 00:00:00 2001 From: Teo Camarasu Date: Wed, 7 May 2025 16:26:33 +0100 Subject: [PATCH 9/9] wip Change-Id: Ia839a09ef05f9db520764067b4a8183f6a6a6964 --- .ghci | 1 + bare_shell.nix | 4 + cabal.project | 2 + diff | 62 + rel8.cabal | 1 + result | 1 + src/Rel8/Schema/HTable/Label.hs | 2 +- src/Rel8/TH.hs | 303 +- src/Rel8Test.hs | 7 + tests/Rel8/Generic/Rel8able/Test.dyn.dump-ds | 8191 +++++++++++++++++ .../Rel8/Generic/Rel8able/Test.dyn.dump-simpl | 20 + .../Generic/Rel8able/Test.dyn.dump-splices | 153 + tests/Rel8/Generic/Rel8able/Test.hs | 232 +- treefmt.toml | 52 + 14 files changed, 8835 insertions(+), 196 deletions(-) create mode 100644 .ghci create mode 100644 bare_shell.nix create mode 100644 diff create mode 120000 result create mode 100644 src/Rel8Test.hs create mode 100644 tests/Rel8/Generic/Rel8able/Test.dyn.dump-ds create mode 100644 tests/Rel8/Generic/Rel8able/Test.dyn.dump-simpl create mode 100644 tests/Rel8/Generic/Rel8able/Test.dyn.dump-splices create mode 100644 treefmt.toml diff --git a/.ghci b/.ghci new file mode 100644 index 00000000..a48e262f --- /dev/null +++ b/.ghci @@ -0,0 +1 @@ +:set -XDeriveAnyClass -XDeriveGeneric -XTemplateHaskell diff --git a/bare_shell.nix b/bare_shell.nix new file mode 100644 index 00000000..e6efd0cf --- /dev/null +++ b/bare_shell.nix @@ -0,0 +1,4 @@ +let pkgs = (builtins.getFlake "nixpkgs").legacyPackages.x86_64-linux; +in + pkgs.mkShell { buildInputs = with pkgs; [ghc cabal-install postgresql postgresql.dev zlib + pkg-config];} diff --git a/cabal.project b/cabal.project index 9ea02062..2aedce5e 100644 --- a/cabal.project +++ b/cabal.project @@ -1,3 +1,5 @@ packages: . constraints: ansi-wl-pprint < 1.0.0 allow-newer: base16:base, base16:deepseq, base16:text + +tests: true diff --git a/diff b/diff new file mode 100644 index 00000000..821ccab4 --- /dev/null +++ b/diff @@ -0,0 +1,62 @@ + +commit b384871b242cef11e717f2671e0128f75887e3b0 +Author: remeike +Date: Mon Aug 5 09:07:59 2024 -0400 + + Fix regex match operator (#336) + +commit e214b75565439461302342083a9bca59894cf34f +Author: Shane +Date: Tue Jul 30 18:08:25 2024 +0100 + + Remove `Table Expr b` constraint from `materialize` (#334) + + Not only is this not necessary, it can actually act as a barrier to optimisation. The reason I added it was because it seemed like a cheap way to stop someone writing `query' <- materialize query id` — if you return the materialized query from `materialized`, it won't work. Really we would need some sort of `runST` type trick here to do this properly, but that would be too invasive a change. + +commit 149ec23c6f32ff677940ca39d6598cfc3a9593bb +Author: Shane +Date: Mon Jul 15 11:54:22 2024 +0100 + + Add `aggregate{Just,Left,Right,This,That,Those,Here,There}Table{,1}` aggregators (#333) + + These provide another way to do aggregation of `MaybeTable`, `EitherTable` and `TheseTable`s than the existing `aggregate{Maybe,Either,These}Table`. + +commit dbda2da7bc94da0b4118be1ff689aab67f2f56ed +Author: Teo Camarasu +Date: Tue Jul 2 16:41:09 2024 +0100 + + docs: fix haddock link (#332) + + Previously this linked to Prelude.fromIntegral, but we mean Rel8.Num.fromIntegral + +commit 6b0721b4ca53f228775501bbe7e56722aec27a47 +Author: Shane +Date: Mon Jul 1 12:56:48 2024 +0100 + + Expose `listOf` and `nonEmptyOf` (#330) + + It was an oversight that these were ever not exported. + +commit d8ca92fe85ceec0ff4cf55c9156678bd55a23fc1 +Author: Teo Camarasu +Date: Thu Jun 20 17:28:57 2024 +0100 + + Fix code block format (#329) + + Without the indentation, this doesn't parse properly + +commit 21b17334864a2abbeac3f953710f9f0e6ac95f10 +Author: Teo Camarasu +Date: Wed May 29 15:56:49 2024 +0100 + + docs: remove empty 'where' clause (#327) + + This hanging where statement seems like a typo or the ghost of a proper where long gone + +commit 6ec03667c472b102f9e447c682cc00c680f1a152 +Author: abigailalice <95150492+abigailalice@users.noreply.github.com> +Date: Wed Apr 3 07:57:50 2024 -0700 + + Fix some markup in haddocks (#318) + + Fixes #315. diff --git a/rel8.cabal b/rel8.cabal index 045f092e..fc68ee22 100644 --- a/rel8.cabal +++ b/rel8.cabal @@ -31,6 +31,7 @@ library , bytestring , case-insensitive , comonad + , containers , contravariant , data-textual , hasql >= 1.6.1.2 && < 1.9 diff --git a/result b/result new file mode 120000 index 00000000..8236b477 --- /dev/null +++ b/result @@ -0,0 +1 @@ +/nix/store/z7sskjfby4bwgamzqyx51nlzchzdszmb-ghc-shell-for-packages \ No newline at end of file diff --git a/src/Rel8/Schema/HTable/Label.hs b/src/Rel8/Schema/HTable/Label.hs index 43c1843f..1eac6848 100644 --- a/src/Rel8/Schema/HTable/Label.hs +++ b/src/Rel8/Schema/HTable/Label.hs @@ -7,7 +7,7 @@ {-# language TypeFamilies #-} module Rel8.Schema.HTable.Label - ( HLabel, hlabel, hrelabel, hunlabel + ( HLabel(HLabel), hlabel, hrelabel, hunlabel , hproject ) where diff --git a/src/Rel8/TH.hs b/src/Rel8/TH.hs index 1e43e198..a157e214 100644 --- a/src/Rel8/TH.hs +++ b/src/Rel8/TH.hs @@ -4,11 +4,17 @@ {-# LANGUAGE BlockArguments #-} {-# LANGUAGE ViewPatterns #-} {-# LANGUAGE TypeFamilies #-} -module Rel8.TH (deriveRel8able) where - -import Prelude ((.), pure, (<$>), ($), fail, map, id, (==), (<>), show, last, error, otherwise) -import Language.Haskell.TH (Name, Q, Dec, conT, Type (AppT, ConT, VarT, TupleT), newName, conP, varP, nameBase, conE, varE, appsE, TyVarBndr(..), varT, tupleT) -import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (DatatypeInfo), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant, constructorName, datatypeVars) +{-# LANGUAGE PolyKinds #-} +{-# LANGUAGE TypeApplications #-} +{-# LANGUAGE RecordWildCards #-} +module Rel8.TH (deriveRel8able, parseDatatype) where + +import Prelude +import Language.Haskell.TH (Q) +import qualified Language.Haskell.TH as TH +import qualified Language.Haskell.TH.Syntax as TH +import Language.Haskell.TH.Datatype (reifyDatatype, ConstructorInfo (ConstructorInfo), DatatypeInfo (..), datatypeCons, constructorFields, ConstructorVariant (RecordConstructor), constructorVariant, constructorName, datatypeVars) +import qualified Language.Haskell.TH.Datatype as TH.Datatype import Rel8.Generic.Rel8able ( Rel8able(..) ) import Rel8.Schema.Result (Result) import Data.Foldable (foldl', toList ) @@ -20,85 +26,214 @@ import Rel8.Kind.Context (SContext(..)) import Data.Functor ( (<&>) ) import Data.List.NonEmpty ( NonEmpty( (:|) ) ) import Rel8.Column ( Column ) +import Rel8.Column.Maybe ( HMaybe ) +import Rel8.Schema.HTable.Maybe ( HMaybeTable ) import Rel8.Expr ( Expr ) -import Rel8.Table ( Columns ) - -deriveRel8able :: Name -> Q [Dec] -deriveRel8able name = do - DatatypeInfo{ datatypeVars = (last -> fBinder), datatypeCons = [ ConstructorInfo{ constructorName, constructorFields = f1:fs, constructorVariant = RecordConstructor (fieldName1:fieldNames) } ]} <- reifyDatatype name - - let f = case fBinder of - PlainTV a _ -> a - KindedTV a _ _ -> a - - contextName <- newName "context" - name1 <- newName $ nameBase fieldName1 - names <- for fieldNames $ newName . nameBase - - let allNames = name1 :| names - - let - unpackP = - foldl' - (\e n -> [p| HProduct $e (HIdentity $( varP n )) |]) - [p| HIdentity $( varP name1 ) |] - names - - unmk (x :| xs) = - foldl' - (\e n -> [| HProduct $e (HIdentity $n) |]) - [| HIdentity $x |] - xs - - mk xs = appsE (conE constructorName : toList xs) - - id - [d| instance Rel8able $( conT name ) where - type GColumns $( conT name) = - $( - foldl' - (\t x -> [t| HProduct $t $(unColumn f x) |]) - (unColumn f f1) - fs - ) - - type GFromExprs $( conT name ) = - $( conT name ) Result - - gfromColumns $( varP contextName ) $unpackP = - case $( varE contextName ) of - SExpr -> $( mk $ varE <$> allNames ) - SField -> $( mk $ varE <$> allNames ) - SName -> $( mk $ varE <$> allNames ) - SResult -> $( mk $ allNames <&> \x -> [| runIdentity $( varE x ) |] ) - - gtoColumns $(varP contextName) $( conP constructorName (map varP (name1:names)) ) = - case $( varE contextName ) of - SExpr -> $( unmk $ varE <$> allNames ) - SField -> $( unmk $ varE <$> allNames ) - SName -> $( unmk $ varE <$> allNames ) - SResult -> $( unmk $ allNames <&> \x -> [| Identity $( varE x ) |] ) - - gfromResult $unpackP = - $( mk $ allNames <&> \x -> [| runIdentity $( varE x ) |] ) - - gtoResult $( conP constructorName (map varP (name1:names)) ) = - $( unmk $ allNames <&> \x -> [| Identity $( varE x ) |] ) - |] - - -unColumn :: Name -> Type -> Q Type -unColumn _ (AppT (AppT (ConT _Column) _f) t) | _Column == ''Column = [t| HIdentity $(pure t) |] -unColumn f t = [t| Columns $(instantiate t) |] +import Rel8.Table (Columns, toColumns, fromColumns, fromResult, toResult, FromExprs) +import Rel8.Schema.Kind (Context) +import Data.List (unsnoc) +import Debug.Trace +import Rel8.Schema.HTable.Label (HLabel(..)) +import Data.Data (constrFields) +import Data.Aeson (parseIndexedJSON) +import qualified Data.Map.Strict as M + + +-- We derive a Rel8able instance using TH. +-- At it's core a Rel8able instance is a bijection between a datatype and the the SQL columns corresponding to its fields. +-- We only support datatypes with one constructor. +-- The datatype must have exactly one type arg and it is the index for our HKD stuff. +-- Question: Can we support multiple type args? +--- +-- We have three types of fields: +-- 1) Column f Text : Directly using Column, easy. This is just a special case of (3) +-- 2) OtherType f : They embed another Rel8able type +-- 3) TabledType : They embed a type with a table instance. +-- eg, we might see something like (Column f Text, Column f Bool). (,) has a Table instance, +-- so we know how to map this type to SQL columns. +-- +-- We represent a vector of SQL columns with basically: +-- HLabel "field label" (HIdentity Text) `HProduct` HLabel "another field" (HIdentity Bool) ... +-- Nothing too complicated here. I'm not sure if we are allowed to leave the HLabels out or if that will cause everything to explode. +-- This H* stuff is also used to thread around contexts if you look at the definitions of these things + +data ParsedDatatype = + ParsedDatatype + { name :: TH.Name + , conName :: TH.Name + , fBinder :: TH.Name + , fields :: [ParsedField] + } + deriving (Show) + +data ParsedField = + ParsedField + { fieldSelector :: Maybe TH.Name + , fieldVariant :: ParsedFieldVariant + , fieldType :: TH.Type + , fieldColumnType :: TH.Type + , fieldFreshName :: TH.Name + } + deriving (Show) + +data ParsedFieldVariant = + ColumnField + | Rel8ableField -- TODO rename to table field + deriving (Show) + +-- | 'fail' but indicate that the failure is coming from our code +prettyFail :: String -> Q a +prettyFail str = fail $ "deriveRel8able: " ++ str + +parseDatatype :: DatatypeInfo -> Q ParsedDatatype +parseDatatype datatypeInfo = do + constructor <- + -- Check that it only has one constructor + case datatypeCons datatypeInfo of + [cons] -> pure cons + _ -> prettyFail "exepecting a datatype with exactly 1 constructor" + let conName = TH.Datatype.constructorName constructor + let name = datatypeName datatypeInfo + fBinder <- case unsnoc $ datatypeInstTypes datatypeInfo of + Just (_, candidate) -> parseFBinder candidate + Nothing -> prettyFail "expecting the datatype to have a context type parameter like `data Foo f = ...`" + let fieldSelectors = case constructorVariant constructor of + -- Only record constructors have field names + RecordConstructor names -> map Just names + _ -> repeat Nothing + let columnName = ''Column + fields <- + mapM (uncurry $ parseField columnName fBinder) $ + zip (constructorFields constructor) fieldSelectors + -- TODO: check that we have at least one field, fail otherwise + pure ParsedDatatype{..} + +parseFBinder :: TH.Type -> Q TH.Name +parseFBinder (TH.SigT x (TH.ConT kind)) + | kind == ''Context = parseFBinder x + | otherwise = prettyFail $ "expected kind encountered for the context type argument: " ++ show kind +parseFBinder (TH.VarT name) = pure name +parseFBinder typ = prettyFail $ "unexpected type encountered while looking for the context type argument to the datatype: " ++ show typ + +typeApps :: TH.Type -> [TH.Type] +typeApps x = go x [] + where + go (TH.AppT x y) args = go x (y:args) + go x args = x:args + +unTypeApps :: TH.Type -> [TH.Type] -> TH.Type +unTypeApps = foldl' TH.AppT + +parseField :: TH.Name -> TH.Name -> TH.Type -> Maybe TH.Name -> Q ParsedField +parseField columnName fBinder fieldType fieldSelector + | (TH.ConT columnCandidate `TH.AppT` TH.VarT fBinderCandidate `TH.AppT` subType) <- fieldType + , columnCandidate == columnName + , fBinderCandidate == fBinder + = do + n <- TH.newName "x" + pure $ ParsedField { fieldSelector = fieldSelector, fieldVariant = ColumnField, fieldType = subType, fieldColumnType = TH.ConT ''HIdentity `TH.AppT` subType, fieldFreshName = n} + | (TH.ConT hmaybeCandidate `TH.AppT` TH.VarT fBinderCandidate `TH.AppT` subType) <- fieldType + , hmaybeCandidate == ''HMaybe + , fBinderCandidate == fBinder + = do + n <- TH.newName "x" + innerType <- [t| Columns $(pure subType)|] + let columnType = TH.Datatype.applySubstitution (M.fromList [(fBinder, TH.ConT ''Expr)]) $ TH.ConT ''HMaybeTable `TH.AppT` innerType + pure $ ParsedField { fieldSelector = fieldSelector, fieldVariant = Rel8ableField, fieldType = subType, fieldColumnType = columnType, fieldFreshName = n} + | subType:(TH.VarT name):other_apps <- typeApps fieldType + , name == fBinder + = do + traceShowM (subType:(TH.VarT name):other_apps) + n <- TH.newName "x" + columnType <- [t|Columns ($(pure $ TH.Datatype.applySubstitution (M.fromList [(fBinder, TH.ConT ''Expr)])$ unTypeApps subType ((TH.ConT ''Expr):other_apps))) |] + traceM $ TH.pprint columnType + pure $ ParsedField { fieldSelector = fieldSelector, fieldVariant = Rel8ableField, fieldType = subType, fieldColumnType = columnType, fieldFreshName = n} + | otherwise = prettyFail $ "Field of unexpected type: " ++ show fieldType ++ show (typeApps fieldType) + +generateGColumns :: ParsedDatatype -> Q TH.Type +generateGColumns ParsedDatatype{..} = + foldr1 (\x y -> [t|HProduct $x $y|]) $ map generateGColumn fields where - instantiate = \case - VarT v | v == f -> [t| Expr |] - | otherwise -> varT v - - AppT x y -> [t| $(instantiate x) $(instantiate y) |] - - TupleT n -> tupleT n - - ConT n -> conT n + generateGColumn ParsedField{..} = + [t| $(pure fieldColumnType)|] + >>= labelled fieldSelector + labelled Nothing x = pure x + labelled (Just (TH.Name (TH.OccName fieldSelector) _)) x = [t|HLabel $(TH.litT $ TH.strTyLit fieldSelector) $(pure x)|] + +generateColumnsE :: ParsedDatatype -> (TH.Exp -> TH.Exp) -> (TH.Type -> TH.Exp -> TH.Exp) -> TH.Exp +generateColumnsE ParsedDatatype{..} f g = + foldr1 (\x y -> TH.ConE 'HProduct `TH.AppE` x `TH.AppE` y) $ map generateColumnE fields + where + generateColumnE ParsedField{..} = + labelled fieldSelector $ + case fieldVariant of + ColumnField -> TH.ConE 'HIdentity `TH.AppE` (f $ TH.VarE fieldFreshName) + Rel8ableField -> (g fieldType $ TH.VarE fieldFreshName) + labelled Nothing x = x + labelled (Just _) x = TH.ConE 'HLabel `TH.AppE`x + +generateColumnsP :: ParsedDatatype -> TH.Pat +generateColumnsP ParsedDatatype{..} = + foldr1 (\x y -> TH.ConP 'HProduct [] [x, y]) $ map generateColumnP fields + where + generateColumnP ParsedField{..} = + labelled fieldSelector $ + case fieldVariant of + ColumnField -> TH.ConP 'HIdentity [] [TH.VarP fieldFreshName] + Rel8ableField -> TH.VarP fieldFreshName + labelled Nothing x = x + labelled (Just _) x = TH.ConP 'HLabel [] [x] + +generateConstructorE :: ParsedDatatype -> (TH.Exp -> TH.Exp) -> (TH.Type -> TH.Exp -> TH.Exp) -> Q TH.Exp +generateConstructorE parsedDatatype f g = + pure $ foldl' TH.AppE (TH.ConE (conName parsedDatatype)) . map generateFieldE $ fields parsedDatatype + where + generateFieldE ParsedField{..} = + case fieldVariant of + ColumnField -> f . TH.VarE $ fieldFreshName + Rel8ableField -> g fieldType $ (TH.VarE fieldFreshName `TH.SigE` (fieldColumnType `TH.AppT` TH.WildCardT)) - other -> error $ show other +deriveRel8able :: TH.Name -> Q [TH.Dec] +deriveRel8able name = do + datatypeInfo <- reifyDatatype name + parsedDatatype <- parseDatatype datatypeInfo + let gColumns = generateGColumns parsedDatatype + let constructorE = generateConstructorE parsedDatatype + let constructorP = pure $ TH.ConP (conName parsedDatatype) [] . map (TH.VarP . fieldFreshName) $ fields parsedDatatype + let columnsE f g = pure $ generateColumnsE parsedDatatype f g + let columnsP = pure $ generateColumnsP parsedDatatype + contextName <- TH.newName "context" + [d| + instance Rel8able $(TH.conT name) where + -- Really the Generic code substitutes Expr for f and then does stuff. Maybe we want to move closer to that? + type GColumns $( TH.conT name) = + $( gColumns ) + + type GFromExprs $( TH.conT name ) = + $( TH.conT name ) Result + + -- the rest of the definition is just a few functions to go back and forth between Columns and the datatype + + gfromColumns :: SContext context -> GColumns $(TH.conT name) context -> $(TH.conT name) context + gfromColumns $( TH.varP contextName ) x = + case $( TH.varE contextName ) of + SResult -> case x of $columnsP -> $(constructorE (\x -> TH.VarE 'runIdentity `TH.AppE` x) (\_ x -> TH.VarE 'undefined `TH.AppE` x)) + SExpr -> case x of $columnsP -> $(constructorE id (\_ x -> TH.VarE 'fromColumns `TH.AppE` x)) + SField -> case x of $columnsP -> $(constructorE id (\_ x -> TH.VarE 'fromColumns `TH.AppE` x)) + SName -> case x of $columnsP -> $(constructorE id (\_ x -> TH.VarE 'fromColumns `TH.AppE` x)) + + gtoColumns $(TH.varP contextName) $( constructorP ) = + case $( TH.varE contextName ) of + SExpr -> $(columnsE id (\_ x -> TH.VarE 'toColumns `TH.AppE` x)) + SField -> $(columnsE id (\_ x -> TH.VarE 'toColumns `TH.AppE` x)) + SName -> $(columnsE id (\_ x -> TH.VarE 'toColumns `TH.AppE` x)) + SResult -> $(columnsE (\x -> TH.ConE 'Identity `TH.AppE` x) (\_ x -> TH.VarE 'undefined `TH.AppE` x)) + + gfromResult $columnsP = undefined + -- TODO: get rid of type application. Use a signature that references the generic value instead + -- $( constructorE (\x -> TH.VarE 'runIdentity `TH.AppE` x) (\ft x -> (TH.VarE 'fromResult `TH.AppTypeE` TH.ConT ''Result `TH.AppTypeE` (ft `TH.AppT` TH.ConT ''Result) `TH.AppE` x))) + + gtoResult $constructorP = undefined + -- TODO: get rid of type application. Use a signature that references the generic value instead + -- $( columnsE (\x -> TH.ConE 'Identity `TH.AppE` x) (\ft x -> (TH.VarE 'toResult `TH.AppTypeE` TH.ConT ''Result `TH.AppTypeE` (ft `TH.AppT` TH.ConT ''Result) `TH.AppE` x))) + |] diff --git a/src/Rel8Test.hs b/src/Rel8Test.hs new file mode 100644 index 00000000..d270eb31 --- /dev/null +++ b/src/Rel8Test.hs @@ -0,0 +1,7 @@ +-- | +{-# language DuplicateRecordFields #-} + +module Rel8Test where +import Rel8 (text) + +foo = text diff --git a/tests/Rel8/Generic/Rel8able/Test.dyn.dump-ds b/tests/Rel8/Generic/Rel8able/Test.dyn.dump-ds new file mode 100644 index 00000000..1c6873d8 --- /dev/null +++ b/tests/Rel8/Generic/Rel8able/Test.dyn.dump-ds @@ -0,0 +1,8191 @@ + +==================== Desugar (after optimization) ==================== +2025-03-21 18:03:48.144652407 UTC + +Result size of Desugar (after optimization) + = {terms: 308, types: 2,825, coercions: 7,103, joins: 0/18} + +-- RHS size: {terms: 9, types: 11, coercions: 209, joins: 0/0} +$cp1Rel8able_a11Hz + :: HTable + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns TableTest) +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=False, ConLike=False, WorkFree=False, Expandable=False, + Guidance=IF_ARGS [] 160 0}] +$cp1Rel8able_a11Hz + = (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.$fHTableHLabel + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + @"foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.$fHTableHIdentity + @Bool + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fSqlconstrainta + @DBType + @Bool + (rel8-1.6.0.0-inplace:Rel8.Type.$fDBTypeBool + `cast` ((DBType + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:Unnullify'[0] + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_N))_R + :: DBType Bool + ~R# DBType + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool) Bool))) + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullablea + @Bool + ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullable'Falsea + @Bool + ((ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False)) + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: (False ~ False) + ~R# (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool ~ False)))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' False Bool + ~R# rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool) Bool))))) + ((ghc-prim:GHC.CString.unpackCString# "foo"#) + `cast` (Sym (GHC.TypeLits.N:SSymbol[0] <"foo">_N) + ; Sym (GHC.TypeLits.N:KnownSymbol[0] <"foo">_N) + :: String ~R# GHC.TypeLits.KnownSymbol "foo"))) + `cast` ((HTable + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_R + :: HTable + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# HTable + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns TableTest)) + +-- RHS size: {terms: 5, types: 7, coercions: 88, joins: 0/0} +$cto_a11GQ + :: forall (f :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context) x. + GHC.Generics.Rep (TableTest f) x -> TableTest f +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=True)}] +$cto_a11GQ + = \ (@(f_a11G2 :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context)) + (@x_a11GT) + (ds_d1217 :: GHC.Generics.Rep (TableTest f_a11G2) x_a11GT) -> + Rel8.Generic.Rel8able.Test.TableTest + @f_a11G2 + (ds_d1217 + `cast` (Sub (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N) _N + ; GHC.Generics.N:M1[0] + <*>_N + _P + _P + _R _N + ; GHC.Generics.N:M1[0] + <*>_N + _P + _P + _R _N + ; GHC.Generics.N:M1[0] + <*>_N + _P + _P + _R _N + ; GHC.Generics.N:K1[0] + <*>_N _P _R _P + :: GHC.Generics.Rep (TableTest f_a11G2) x_a11GT + ~R# Column f_a11G2 Bool)) + +-- RHS size: {terms: 7, types: 9, coercions: 92, joins: 0/0} +$cfrom_a11G4 + :: forall (f :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context) x. + TableTest f -> GHC.Generics.Rep (TableTest f) x +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=True)}] +$cfrom_a11G4 + = \ (@(f_a11G2 :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context)) + (@x_a11G7) + (x_a11FT :: TableTest f_a11G2) -> + (case x_a11FT of { TableTest g1_a11FY -> + g1_a11FY + `cast` (Sym (GHC.Generics.N:K1[0] + <*>_N _P _R _P) + ; Sym (GHC.Generics.N:M1[0] + <*>_N + _P + _P + _R) _N + ; Sym (GHC.Generics.N:M1[0] + <*>_N + _P + _P + _R) _N + :: Column f_a11G2 Bool + ~R# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Column f_a11G2 Bool))) + x_a11G7) + }) + `cast` (Sym (GHC.Generics.N:M1[0] + <*>_N + _P + _P + _R) _N + ; Sub (Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)) _N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Column f_a11G2 Bool))) + x_a11G7 + ~R# GHC.Generics.Rep (TableTest f_a11G2) x_a11G7) + +-- RHS size: {terms: 4, types: 5, coercions: 0, joins: 0/0} +Rel8.Generic.Rel8able.Test.$fGenericTableTest [InlPrag=CONLIKE] + :: forall (f :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context). + Generic (TableTest f) +[LclIdX[DFunId], + Unf=DFun: \ (@(f_a11de :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context)) -> + GHC.Generics.C:Generic TYPE: TableTest f_a11de + $cfrom_a11G4 @f_a11de + $cto_a11GQ @f_a11de] +Rel8.Generic.Rel8able.Test.$fGenericTableTest + = \ (@(f_a11G2 :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context)) -> + GHC.Generics.C:Generic + @(TableTest f_a11G2) ($cfrom_a11G4 @f_a11G2) ($cto_a11GQ @f_a11G2) + +Rec { +-- RHS size: {terms: 6, types: 1, coercions: 0, joins: 0/0} +Rel8.Generic.Rel8able.Test.$fRel8ableTableTest [InlPrag=CONLIKE] + :: Rel8able TableTest +[LclIdX[DFunId], + Unf=DFun: \ -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.C:Rel8able TYPE: TableTest + $cp1Rel8able_a11Hz + $cgfromColumns_a11HE + $cgtoColumns_a11I2 + $cgfromResult_a11Io + $cgtoResult_a11IB] +Rel8.Generic.Rel8able.Test.$fRel8ableTableTest + = rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.C:Rel8able + @TableTest + $cp1Rel8able_a11Hz + $cgfromColumns_a11HE + $cgtoColumns_a11I2 + $cgfromResult_a11Io + $cgtoResult_a11IB + +-- RHS size: {terms: 94, + types: 1,016, + coercions: 2,581, + joins: 0/9} +$cgtoColumns_a11I2 [Occ=LoopBreaker] + :: forall (context :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context). + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SContext context + -> TableTest context + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest context +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=False, Expandable=False, + Guidance=NEVER}] +$cgtoColumns_a11I2 + = \ (@(context_a11I5 :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context)) -> + let { + $d~_a11PV :: False ~ False + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=IF_ARGS [] 0 10}] + $d~_a11PV + = ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False) } in + let { + $dNullable'_a11PT + :: rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' False Bool + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 20 0}] + $dNullable'_a11PT + = rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullable'Falsea + @Bool + ($d~_a11PV + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: (False ~ False) + ~R# (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool + ~ False))) } in + let { + $dNullable_a11PQ :: Nullable Bool + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 20 0}] + $dNullable_a11PQ + = rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullablea + @Bool + ($dNullable'_a11PT + `cast` ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' False Bool + ~R# rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool) Bool)) } in + let { + $dSql_a11PM :: Sql DBType Bool + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 30 0}] + $dSql_a11PM + = rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fSqlconstrainta + @DBType + @Bool + (rel8-1.6.0.0-inplace:Rel8.Type.$fDBTypeBool + `cast` ((DBType + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:Unnullify'[0] + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_N))_R + :: DBType Bool + ~R# DBType + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool) Bool))) + $dNullable_a11PQ } in + let { + $dTable_a11PF :: Table Expr (Expr Bool) + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 20 0}] + $dTable_a11PF + = rel8-1.6.0.0-inplace:Rel8.Expr.$fTableExprExpr + @Bool $dSql_a11PM } in + let { + $dSRel8able_i1288 + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Expr + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 190 0}] + $dSRel8able_i1288 + = rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSRel8abletcontext + @TableTest + @Expr + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Expr) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest @Expr) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool))) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Expr Bool))))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool)))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool)))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Expr))))) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM11 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM10 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM1 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + @(Expr Bool) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @GHC.Generics.R + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ($dTable_a11PF + `cast` (Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalCONSTRAINTTTable[0] + _N _N)) + :: Table Expr (Expr Bool) + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Table.TTable + Expr (Expr Bool)))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Expr Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 + GHC.Generics.R (Expr Bool)))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Expr))))) + ((ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_R + :: (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Expr))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest))) } in + let { + df_i1289 + :: forall table. + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest (Field table) + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 210 0}] + df_i1289 + = \ (@table_a11PX) -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSRel8abletcontext + @TableTest + @(Field table_a11PX) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest (Field table_a11PX)) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest + @(Field table_a11PX)) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool)))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool)))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Field table_a11PX Bool))) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R + (Field table_a11PX Bool))))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Field table_a11PX Bool)))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool)))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Field table_a11PX Bool)))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Field table_a11PX Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest (Field table_a11PX)))))) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM11 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11PX)) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM10 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11PX)) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool))) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM1 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11PX)) + @(Field table_a11PX Bool) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Field table_a11PX Bool)) + @GHC.Generics.R + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Schema.Field.$fTableFieldField + @Bool @table_a11PX $dSql_a11PM) + `cast` (Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalCONSTRAINTTTable[0] + _N _N)) + :: Table (Field table_a11PX) (Field table_a11PX Bool) + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Table.TTable + (Field table_a11PX) (Field table_a11PX Bool)))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Field table_a11PX Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Field table_a11PX Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Field table_a11PX Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 + GHC.Generics.R + (Field table_a11PX Bool)))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11PX)) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11PX Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11PX)) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest (Field table_a11PX)))))) + ((ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Field.D:R:ColumnsField[0] + _N _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_R + :: (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest (Field table_a11PX)))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest))) } in + let { + $dSRel8able1_i128b + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Name + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 210 0}] + $dSRel8able1_i128b + = rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSRel8abletcontext + @TableTest + @Name + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Name) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest @Name) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool))) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Name Bool))))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool)))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool)))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Name))))) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM11 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM10 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool))) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM1 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + @(Name Bool) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Name Bool)) + @GHC.Generics.R + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Schema.Name.$fTableNameName + @Bool $dSql_a11PM) + `cast` (Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalCONSTRAINTTTable[0] + _N _N)) + :: Table Name (Name Bool) + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Table.TTable + Name (Name Bool)))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Name Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Name Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Name Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 + GHC.Generics.R (Name Bool)))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Name))))) + ((ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Name.D:R:ColumnsName[0] + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_R + :: (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Name))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest))) } in + let { + $d(%,,%)_i128c + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SSerialize TableTest + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=True, ConLike=True, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 210 10}] + $d(%,,%)_i128c + = (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Result) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest + @Data.Functor.Identity.Identity) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Data.Functor.Identity.Identity)))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M11 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M10 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M1 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @(Expr Bool) + @Bool + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @GHC.Generics.R + @(GHC.Generics.K1 GHC.Generics.R Bool) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSerializeFalseexpra + @Bool + @(Expr Bool) + ((ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False)) + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N + _N)))_N) + _N)_R + :: (False ~ False) + ~R# ((Bool + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.== Transpose + Data.Functor.Identity.Identity + (Expr + Bool)) + ~ False))) + ($dTable_a11PF + `cast` ((Table + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ContextExpr[0] + _N)) + _N)_R + :: Table Expr (Expr Bool) + ~R# Table (Context (Expr Bool)) (Expr Bool))) + ((ghc-prim:GHC.Types.Eq# + @(*) @Bool @Bool @~(_N :: Bool ghc-prim:GHC.Prim.~# Bool)) + `cast` (((~) + <*>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:FromExprsExpr[0] + _N)) + _N)_R + :: (Bool ~ Bool) ~R# (FromExprs (Expr Bool) ~ Bool)))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N _N)))_N) + _N + _N)_R + ; Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:EvalCONSTRAINTTSerialize[0] + _N _N)) + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + False (Expr Bool) Bool + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + (Expr Bool) Bool))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Expr Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R (Expr Bool))) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R Bool + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R Bool)))), + ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((%,,%) + _N + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)) + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_N)_R + :: (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))))) + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)))), + rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Result))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest)) } in + \ (ds_i128d + :: rel8-1.6.0.0-inplace:Rel8.Kind.Context.SContext + context_a11I5) -> + case ds_i128d of { + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SExpr co_i128h -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.stoColumns + @TableTest + @context_a11I5 + ($dSRel8able_i1288 + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + _N (Sym co_i128h))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Expr + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest context_a11I5)); + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SField @table_i128j + co_i128k -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.stoColumns + @TableTest + @context_a11I5 + ((df_i1289 @table_i128j) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + _N (Sym co_i128k))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest (Field table_i128j) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest context_a11I5)); + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SName co_i128m -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.stoColumns + @TableTest + @context_a11I5 + ($dSRel8able1_i128b + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + _N (Sym co_i128m))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Name + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest context_a11I5)); + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SResult co_i128p -> + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.stoResult + @TableTest $d(%,,%)_i128c) + `cast` ((TableTest (Sym co_i128p))_R + %_N ->_R (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + _N (Sym co_i128p))_R + :: (TableTest Data.Functor.Identity.Identity + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Data.Functor.Identity.Identity) + ~R# (TableTest context_a11I5 + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest context_a11I5)) + } + +-- RHS size: {terms: 94, + types: 1,016, + coercions: 2,581, + joins: 0/9} +$cgfromColumns_a11HE [Occ=LoopBreaker] + :: forall (context :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context). + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SContext context + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest context + -> TableTest context +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=False, Expandable=False, + Guidance=NEVER}] +$cgfromColumns_a11HE + = \ (@(context_a11HH :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context)) -> + let { + $d~_a11KW :: False ~ False + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=IF_ARGS [] 0 10}] + $d~_a11KW + = ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False) } in + let { + $dNullable'_a11KU + :: rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' False Bool + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 20 0}] + $dNullable'_a11KU + = rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullable'Falsea + @Bool + ($d~_a11KW + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: (False ~ False) + ~R# (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool + ~ False))) } in + let { + $dNullable_a11KQ :: Nullable Bool + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 20 0}] + $dNullable_a11KQ + = rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullablea + @Bool + ($dNullable'_a11KU + `cast` ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' False Bool + ~R# rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool) Bool)) } in + let { + $dSql_a11KO :: Sql DBType Bool + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 30 0}] + $dSql_a11KO + = rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fSqlconstrainta + @DBType + @Bool + (rel8-1.6.0.0-inplace:Rel8.Type.$fDBTypeBool + `cast` ((DBType + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:Unnullify'[0] + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_N))_R + :: DBType Bool + ~R# DBType + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe Bool) Bool))) + $dNullable_a11KQ } in + let { + $dTable_a11Ky :: Table Expr (Expr Bool) + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 20 0}] + $dTable_a11Ky + = rel8-1.6.0.0-inplace:Rel8.Expr.$fTableExprExpr + @Bool $dSql_a11KO } in + let { + $dSRel8able_i12cP + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Expr + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 190 0}] + $dSRel8able_i12cP + = rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSRel8abletcontext + @TableTest + @Expr + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Expr) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest @Expr) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool))) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Expr Bool))))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool)))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool)))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Expr Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Expr))))) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM11 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM10 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM1 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + @(Expr Bool) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @GHC.Generics.R + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ($dTable_a11Ky + `cast` (Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalCONSTRAINTTTable[0] + _N _N)) + :: Table Expr (Expr Bool) + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Table.TTable + Expr (Expr Bool)))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Expr Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 + GHC.Generics.R (Expr Bool)))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Expr) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Expr))))) + ((ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_R + :: (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Expr))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest))) } in + let { + df_i12cQ + :: forall table. + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest (Field table) + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 210 0}] + df_i12cQ + = \ (@table_a11KY) -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSRel8abletcontext + @TableTest + @(Field table_a11KY) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest (Field table_a11KY)) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest + @(Field table_a11KY)) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool)))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool)))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Field table_a11KY Bool))) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R + (Field table_a11KY Bool))))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Field table_a11KY Bool)))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool)))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Field table_a11KY Bool)))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Field table_a11KY Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest (Field table_a11KY)))))) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM11 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11KY)) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM10 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11KY)) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool))) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM1 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11KY)) + @(Field table_a11KY Bool) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Field table_a11KY Bool)) + @GHC.Generics.R + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Schema.Field.$fTableFieldField + @Bool @table_a11KY $dSql_a11KO) + `cast` (Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalCONSTRAINTTTable[0] + _N _N)) + :: Table (Field table_a11KY) (Field table_a11KY Bool) + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Table.TTable + (Field table_a11KY) (Field table_a11KY Bool)))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Field table_a11KY Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Field table_a11KY Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Field table_a11KY Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 + GHC.Generics.R + (Field table_a11KY Bool)))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11KY)) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Field table_a11KY Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable (Field table_a11KY)) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest (Field table_a11KY)))))) + ((ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Field.D:R:ColumnsField[0] + _N _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_R + :: (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest (Field table_a11KY)))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest))) } in + let { + $dSRel8able1_i12cS + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Name + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=False, ConLike=False, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 210 0}] + $dSRel8able1_i12cS + = rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSRel8abletcontext + @TableTest + @Name + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Name) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest @Name) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool))) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 + GHC.Generics.R (Name Bool))))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool)))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool)))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R (Name Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Name))))) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM11 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool)))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM10 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool))) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGTable_Table_ColumnsM1 + @(rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + @(Name Bool) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Name Bool)) + @GHC.Generics.R + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Schema.Name.$fTableNameName + @Bool $dSql_a11KO) + `cast` (Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalCONSTRAINTTTable[0] + _N _N)) + :: Table Name (Name Bool) + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Table.TTable + Name (Name Bool)))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Name Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Name Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Name Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 + GHC.Generics.R (Name Bool)))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Name Bool))))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GTable + (rel8-1.6.0.0-inplace:Rel8.Table.TTable Name) + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Name))))) + ((ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Name.D:R:ColumnsName[0] + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_R + :: (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Name))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest))) } in + let { + $d(%,,%)_i12cT + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SSerialize TableTest + [LclId, + Unf=Unf{Src=, TopLvl=False, + Value=True, ConLike=True, WorkFree=False, Expandable=True, + Guidance=IF_ARGS [] 210 10}] + $d(%,,%)_i12cT + = (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Result) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest + @Data.Functor.Identity.Identity) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Data.Functor.Identity.Identity)))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M11 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M10 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M1 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @(Expr Bool) + @Bool + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @GHC.Generics.R + @(GHC.Generics.K1 GHC.Generics.R Bool) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSerializeFalseexpra + @Bool + @(Expr Bool) + ((ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False)) + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N + _N)))_N) + _N)_R + :: (False ~ False) + ~R# ((Bool + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.== Transpose + Data.Functor.Identity.Identity + (Expr + Bool)) + ~ False))) + ($dTable_a11Ky + `cast` ((Table + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ContextExpr[0] + _N)) + _N)_R + :: Table Expr (Expr Bool) + ~R# Table (Context (Expr Bool)) (Expr Bool))) + ((ghc-prim:GHC.Types.Eq# + @(*) @Bool @Bool @~(_N :: Bool ghc-prim:GHC.Prim.~# Bool)) + `cast` (((~) + <*>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:FromExprsExpr[0] + _N)) + _N)_R + :: (Bool ~ Bool) ~R# (FromExprs (Expr Bool) ~ Bool)))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N _N)))_N) + _N + _N)_R + ; Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:EvalCONSTRAINTTSerialize[0] + _N _N)) + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + False (Expr Bool) Bool + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + (Expr Bool) Bool))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Expr Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R (Expr Bool))) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R Bool + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R Bool)))), + ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((%,,%) + _N + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)) + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_N)_R + :: (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))))) + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)))), + rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Result))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest)) } in + \ (ds_i12cU + :: rel8-1.6.0.0-inplace:Rel8.Kind.Context.SContext + context_a11HH) -> + case ds_i12cU of { + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SExpr co_i12cY -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.sfromColumns + @TableTest + @context_a11HH + ($dSRel8able_i12cP + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + _N (Sym co_i12cY))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Expr + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest context_a11HH)); + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SField @table_i12d2 + co_i12d3 -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.sfromColumns + @TableTest + @context_a11HH + ((df_i12cQ @table_i12d2) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + _N (Sym co_i12d3))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest (Field table_i12d2) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest context_a11HH)); + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SName co_i12d5 -> + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.sfromColumns + @TableTest + @context_a11HH + ($dSRel8able1_i12cS + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + _N (Sym co_i12d5))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest Name + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.SRel8able + TableTest context_a11HH)); + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SResult co_i12d8 -> + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.sfromResult + @TableTest $d(%,,%)_i12cT) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + _N (Sym co_i12d8))_R + %_N ->_R (TableTest (Sym co_i12d8))_R + :: (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Data.Functor.Identity.Identity + -> TableTest Data.Functor.Identity.Identity) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest context_a11HH + -> TableTest context_a11HH)) + } + +-- RHS size: {terms: 27, types: 346, coercions: 776, joins: 0/0} +$cgfromResult_a11Io [Occ=LoopBreaker] + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Result + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs TableTest +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=False, ConLike=False, WorkFree=False, Expandable=False, + Guidance=IF_ARGS [] 350 0}] +$cgfromResult_a11Io + = case ghc-prim:GHC.Types.eq_sel + @(*) + @(rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs TableTest) + @(TableTest Result) + ((ghc-prim:GHC.Types.Eq# + @(*) + @(TableTest Result) + @(TableTest Result) + @~(_N + :: TableTest Result ghc-prim:GHC.Prim.~# TableTest Result)) + `cast` (((~) + <*>_N + (Sym (Rel8.Generic.Rel8able.Test.R:GFromExprsTableTest[0])) + _N)_R + :: (TableTest Result ~ TableTest Data.Functor.Identity.Identity) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs + TableTest + ~ TableTest Data.Functor.Identity.Identity))) + of co_i12dt + { __DEFAULT -> + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.sfromResult + @TableTest + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Result) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest + @Data.Functor.Identity.Identity) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Data.Functor.Identity.Identity)))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M11 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M10 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M1 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @(Expr Bool) + @Bool + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @GHC.Generics.R + @(GHC.Generics.K1 GHC.Generics.R Bool) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSerializeFalseexpra + @Bool + @(Expr Bool) + ((ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False)) + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N _N)))_N) + _N)_R + :: (False ~ False) + ~R# ((Bool + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.== Transpose + Data.Functor.Identity.Identity + (Expr Bool)) + ~ False))) + ((rel8-1.6.0.0-inplace:Rel8.Expr.$fTableExprExpr + @Bool + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fSqlconstrainta + @DBType + @Bool + (rel8-1.6.0.0-inplace:Rel8.Type.$fDBTypeBool + `cast` ((DBType + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:Unnullify'[0] + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_N))_R + :: DBType Bool + ~R# DBType + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe + Bool) + Bool))) + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullablea + @Bool + ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullable'Falsea + @Bool + ((ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False)) + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: (False ~ False) + ~R# (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe + Bool + ~ False)))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + False Bool + ~R# rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe + Bool) + Bool))))) + `cast` ((Table + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ContextExpr[0] _N)) + _N)_R + :: Table Expr (Expr Bool) + ~R# Table (Context (Expr Bool)) (Expr Bool))) + ((ghc-prim:GHC.Types.Eq# + @(*) @Bool @Bool @~(_N :: Bool ghc-prim:GHC.Prim.~# Bool)) + `cast` (((~) + <*>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:FromExprsExpr[0] + _N)) + _N)_R + :: (Bool ~ Bool) ~R# (FromExprs (Expr Bool) ~ Bool)))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N _N)))_N) + _N + _N)_R + ; Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:EvalCONSTRAINTTSerialize[0] + _N _N)) + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + False (Expr Bool) Bool + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + (Expr Bool) Bool))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Expr Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R (Expr Bool))) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R Bool + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R Bool)))), + ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((%,,%) + _N + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)) + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_N)_R + :: (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))))) + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)))), + rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Result))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns TableTest)))) + `cast` (_R + %_N ->_R Sub (Sym co_i12dt) + :: (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Result + -> TableTest Result) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Result + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs + TableTest)) + } + +-- RHS size: {terms: 27, types: 346, coercions: 776, joins: 0/0} +$cgtoResult_a11IB [Occ=LoopBreaker] + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs TableTest + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Result +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=False, ConLike=False, WorkFree=False, Expandable=False, + Guidance=IF_ARGS [] 350 0}] +$cgtoResult_a11IB + = case ghc-prim:GHC.Types.eq_sel + @(*) + @(rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs TableTest) + @(TableTest Result) + ((ghc-prim:GHC.Types.Eq# + @(*) + @(TableTest Result) + @(TableTest Result) + @~(_N + :: TableTest Result ghc-prim:GHC.Prim.~# TableTest Result)) + `cast` (((~) + <*>_N + (Sym (Rel8.Generic.Rel8able.Test.R:GFromExprsTableTest[0])) + _N)_R + :: (TableTest Result ~ TableTest Data.Functor.Identity.Identity) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs + TableTest + ~ TableTest Data.Functor.Identity.Identity))) + of co_i12dy + { __DEFAULT -> + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.stoResult + @TableTest + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGenericRecord + @(TableTest Result) + (Rel8.Generic.Rel8able.Test.$fGenericTableTest + @Data.Functor.Identity.Identity) + ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordableM1 + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.$fGRecordablerep + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ((ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @~(_N + :: GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)) + ghc-prim:GHC.Prim.~# GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + `cast` (((~) + <* -> *>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)) + _N)_R + :: (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons + "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + ~ GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool))))))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_R + :: rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.K1 GHC.Generics.R Bool)))) + ~R# rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecordable + (GHC.Generics.Rep (TableTest Data.Functor.Identity.Identity)))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M11 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool)))) + @(GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool))) + @(GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M10 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))) + @(GHC.Generics.M1 + GHC.Generics.S + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)) + @(GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.$fGSerialize_Serialize_ColumnsM1M1 + @rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + @(Expr Bool) + @Bool + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @"foo" + @GHC.Generics.NoSourceUnpackedness + @GHC.Generics.NoSourceStrictness + @GHC.Generics.DecidedLazy + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @GHC.Generics.R + @(GHC.Generics.K1 GHC.Generics.R Bool) + @rel8-1.6.0.0-inplace:Rel8.Table.TColumns + ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.$fSerializeFalseexpra + @Bool + @(Expr Bool) + ((ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False)) + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N _N)))_N) + _N)_R + :: (False ~ False) + ~R# ((Bool + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.== Transpose + Data.Functor.Identity.Identity + (Expr Bool)) + ~ False))) + ((rel8-1.6.0.0-inplace:Rel8.Expr.$fTableExprExpr + @Bool + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fSqlconstrainta + @DBType + @Bool + (rel8-1.6.0.0-inplace:Rel8.Type.$fDBTypeBool + `cast` ((DBType + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:Unnullify'[0] + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_N))_R + :: DBType Bool + ~R# DBType + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.Unnullify' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe + Bool) + Bool))) + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullablea + @Bool + ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.$fNullable'Falsea + @Bool + ((ghc-prim:GHC.Types.Eq# + @Bool + @False + @False + @~(_N :: False ghc-prim:GHC.Prim.~# False)) + `cast` (((~) + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: (False ~ False) + ~R# (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe + Bool + ~ False)))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (Sym (rel8-1.6.0.0-inplace:Rel8.Schema.Null.D:R:IsMaybe[1] + _N)) + _N)_R + :: rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + False Bool + ~R# rel8-1.6.0.0-inplace:Rel8.Schema.Null.Nullable' + (rel8-1.6.0.0-inplace:Rel8.Schema.Null.IsMaybe + Bool) + Bool))))) + `cast` ((Table + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ContextExpr[0] _N)) + _N)_R + :: Table Expr (Expr Bool) + ~R# Table (Context (Expr Bool)) (Expr Bool))) + ((ghc-prim:GHC.Types.Eq# + @(*) @Bool @Bool @~(_N :: Bool ghc-prim:GHC.Prim.~# Bool)) + `cast` (((~) + <*>_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:FromExprsExpr[0] + _N)) + _N)_R + :: (Bool ~ Bool) ~R# (FromExprs (Expr Bool) ~ Bool)))) + `cast` ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:==[1] + _N) + ; ((rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.==) + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:TransposetoExpr[0] + _N _N)))_N) + _N + _N)_R + ; Sub (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.D:R:EvalCONSTRAINTTSerialize[0] + _N _N)) + :: rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.Serialize + False (Expr Bool) Bool + ~R# rel8-1.6.0.0-inplace:Rel8.FCF.Eval + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + (Expr Bool) Bool))) + (ghc-prim:GHC.Types.Eq# + @GHC.Generics.Meta + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @(GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + @~(_N + :: GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy + ghc-prim:GHC.Prim.~# GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy)) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @(GHC.Generics.K1 GHC.Generics.R (Expr Bool)) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R (Expr Bool) + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R (Expr Bool))) + (ghc-prim:GHC.Types.Eq# + @(* -> *) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @(GHC.Generics.K1 GHC.Generics.R Bool) + @~(_N + :: GHC.Generics.K1 GHC.Generics.R Bool + ghc-prim:GHC.Prim.~# GHC.Generics.K1 GHC.Generics.R Bool)))), + ghc-prim:GHC.Types.Eq# + @(rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context -> *) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @(rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + @~(_N + :: rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ghc-prim:GHC.Prim.~# rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + Bool))) + `cast` (((%,,%) + _N + (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + _N + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)) + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[0] + _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ((~) + <(* -> *) -> *>_N + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N) + ((rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + <"foo">_N + (Sym (rel8-1.6.0.0-inplace:Rel8.Expr.D:R:ColumnsExpr[0] _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Table.D:R:EvalFUNTColumns[0] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[3] + _N + _N + _N + _N + _N + <"foo">_N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[1] + _N + _N + _N) + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.D:R:GColumns[0] + _N + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + _N + ((GHC.Generics.M1 + <*>_N + _N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[3] + _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:GRecord[0] + _N + _N) + ; (rel8-1.6.0.0-inplace:Rel8.Generic.Record.GRecord + ((GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.M1 + <*>_N + _N + _N + (GHC.Generics.K1 + <*>_N + _N + (Sym (rel8-1.6.0.0-inplace:Rel8.Column.D:R:Column[1] + _N _N)))_N)_N)_N)_N + ; Sym (Rel8.Generic.Rel8able.Test.Rep_TableTest[0] _N)))_N + ; Sym (rel8-1.6.0.0-inplace:Rel8.Generic.Record.D:R:RepRecord[0] + _N)))_N + ; Sym (Rel8.Generic.Rel8able.Test.R:GColumnsTableTest[0])))_N)_R + :: (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 (Expr Bool))))) + (GHC.Generics.M1 + GHC.Generics.D + (GHC.Generics.MetaData + "TableTest" + "Rel8.Generic.Rel8able.Test" + "rel8-1.6.0.0-inplace-tests" + False) + (GHC.Generics.M1 + GHC.Generics.C + (GHC.Generics.MetaCons "TableTest" GHC.Generics.PrefixI True) + (GHC.Generics.S1 + (GHC.Generics.MetaSel + (Just "foo") + GHC.Generics.NoSourceUnpackedness + GHC.Generics.NoSourceStrictness + GHC.Generics.DecidedLazy) + (GHC.Generics.Rec0 Bool)))), + rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool) + ~ rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + "foo" + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) + ~R# (Generic + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Data.Functor.Identity.Identity)), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GSerialize + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.TSerialize + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record + (TableTest Result))), + rel8-1.6.0.0-inplace:Rel8.Generic.Table.Record.GColumns + rel8-1.6.0.0-inplace:Rel8.Table.TColumns + (GHC.Generics.Rep + (rel8-1.6.0.0-inplace:Rel8.Generic.Record.Record (TableTest Expr))) + ~ rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns TableTest)))) + `cast` (Sub (Sym co_i12dy) + %_N ->_R _R + :: (TableTest Result + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Result) + ~R# (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs + TableTest + -> rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns + TableTest Result)) + } +end Rec } + +-- RHS size: {terms: 6, types: 8, coercions: 0, joins: 0/0} +foo + :: forall (f :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context). + TableTest f -> Column f Bool +[LclIdX[[RecSel]], + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=ALWAYS_IF(arity=1,unsat_ok=True,boring_ok=True)}] +foo + = \ (@(f_a11cm :: rel8-1.6.0.0-inplace:Rel8.Schema.Kind.Context)) + (ds_d1210 :: TableTest f_a11cm) -> + case ds_d1210 of { TableTest ds_d1211 -> + break<0>(ds_d1211) ds_d1211 + } + +-- RHS size: {terms: 5, types: 0, coercions: 0, joins: 0/0} +Rel8.Generic.Rel8able.Test.$trModule :: ghc-prim:GHC.Types.Module +[LclIdX, + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=IF_ARGS [] 190 10}] +Rel8.Generic.Rel8able.Test.$trModule + = ghc-prim:GHC.Types.Module + (ghc-prim:GHC.Types.TrNameS "rel8-1.6.0.0-inplace-tests"#) + (ghc-prim:GHC.Types.TrNameS "Rel8.Generic.Rel8able.Test"#) + +-- RHS size: {terms: 3, types: 0, coercions: 0, joins: 0/0} +$krep_a11XE [InlPrag=[~]] :: ghc-prim:GHC.Types.KindRep +[LclId, + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=IF_ARGS [] 10 10}] +$krep_a11XE + = ghc-prim:GHC.Types.KindRepFun + ghc-prim:GHC.Types.krep$*Arr* ghc-prim:GHC.Types.krep$* + +-- RHS size: {terms: 8, types: 0, coercions: 0, joins: 0/0} +Rel8.Generic.Rel8able.Test.$tcTableTest :: ghc-prim:GHC.Types.TyCon +[LclIdX, + Unf=Unf{Src=, TopLvl=True, + Value=True, ConLike=True, WorkFree=True, Expandable=True, + Guidance=IF_ARGS [] 60 10}] +Rel8.Generic.Rel8able.Test.$tcTableTest + = ghc-prim:GHC.Types.TyCon + 3772397620618236740#Word64 + 859721876081271507#Word64 + Rel8.Generic.Rel8able.Test.$trModule + (ghc-prim:GHC.Types.TrNameS "TableTest"#) + 0# + $krep_a11XE + + diff --git a/tests/Rel8/Generic/Rel8able/Test.dyn.dump-simpl b/tests/Rel8/Generic/Rel8able/Test.dyn.dump-simpl new file mode 100644 index 00000000..db73e90c --- /dev/null +++ b/tests/Rel8/Generic/Rel8able/Test.dyn.dump-simpl @@ -0,0 +1,20 @@ + +==================== Simplified expression ==================== +2025-10-24 17:29:07.289753702 UTC + +Rel8.TH.deriveRel8able + (Language.Haskell.TH.Syntax.mkNameG_tc + (GHC.CString.unpackCString# "rel8-1.6.0.0-inplace-tests"#) + (GHC.CString.unpackCString# "Rel8.Generic.Rel8able.Test"#) + (GHC.CString.unpackCString# "TableTest"#)) + + +==================== Simplified expression ==================== +2025-10-24 17:29:07.334209392 UTC + +Rel8.TH.deriveRel8able + (Language.Haskell.TH.Syntax.mkNameG_tc + (GHC.CString.unpackCString# "rel8-1.6.0.0-inplace-tests"#) + (GHC.CString.unpackCString# "Rel8.Generic.Rel8able.Test"#) + (GHC.CString.unpackCString# "TablePair"#)) + diff --git a/tests/Rel8/Generic/Rel8able/Test.dyn.dump-splices b/tests/Rel8/Generic/Rel8able/Test.dyn.dump-splices new file mode 100644 index 00000000..7bcd189d --- /dev/null +++ b/tests/Rel8/Generic/Rel8able/Test.dyn.dump-splices @@ -0,0 +1,153 @@ +/home/teo/git/rel8/tests/Rel8/Generic/Rel8able/Test.hs:42:1-26: Splicing declarations + deriveRel8able ''TableTest + ======> + instance Rel8able TableTest where + type rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns TableTest = rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel "foo" (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel "bar" (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity (Maybe Bool))) + type rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs TableTest = TableTest Result + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gfromColumns + context_a149L + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity x_a149H)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity x_a149J))) + = case context_a149L of + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SResult + -> TableTest + (ghc-internal:GHC.Internal.Data.Functor.Identity.runIdentity + x_a149H) + (ghc-internal:GHC.Internal.Data.Functor.Identity.runIdentity + x_a149J) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SExpr + -> TableTest x_a149H x_a149J + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SField + -> TableTest x_a149H x_a149J + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SName + -> TableTest x_a149H x_a149J + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gtoColumns + context_a149L + (TableTest x_a149H x_a149J) + = case context_a149L of + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SExpr + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a149H)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a149J)) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SField + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a149H)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a149J)) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SName + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a149H)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a149J)) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SResult + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + (ghc-internal:GHC.Internal.Data.Functor.Identity.Identity + x_a149H))) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + (ghc-internal:GHC.Internal.Data.Functor.Identity.Identity + x_a149J))) + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gfromResult + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity x_a149H)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity x_a149J))) + = TableTest + (ghc-internal:GHC.Internal.Data.Functor.Identity.runIdentity + x_a149H) + (ghc-internal:GHC.Internal.Data.Functor.Identity.runIdentity + x_a149J) + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gtoResult + (TableTest x_a149H x_a149J) + = rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + (ghc-internal:GHC.Internal.Data.Functor.Identity.Identity + x_a149H))) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + (ghc-internal:GHC.Internal.Data.Functor.Identity.Identity + x_a149J))) +/home/teo/git/rel8/tests/Rel8/Generic/Rel8able/Test.hs:54:1-26: Splicing declarations + deriveRel8able ''TablePair + ======> + instance Rel8able TablePair where + type rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GColumns TablePair = rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel "foo" (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity Bool)) (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel "bars" (Columns (TableTest Expr))) + type rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.GFromExprs TablePair = TablePair Result + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gfromColumns + context_a14xP + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity x_a14xK)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel x_a14xL)) + = case context_a14xP of + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SResult + -> TablePair + (ghc-internal:GHC.Internal.Data.Functor.Identity.runIdentity + x_a14xK) + (fromColumns x_a14xL) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SExpr + -> TablePair x_a14xK (fromColumns x_a14xL) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SField + -> TablePair x_a14xK (fromColumns x_a14xL) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SName + -> TablePair x_a14xK (fromColumns x_a14xL) + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gtoColumns + context_a14xP + (TablePair x_a14xK x_a14xL) + = case context_a14xP of + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SExpr + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a14xK)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (toColumns x_a14xL)) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SField + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a14xK)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (toColumns x_a14xL)) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SName + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + x_a14xK)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (toColumns x_a14xL)) + rel8-1.6.0.0-inplace:Rel8.Kind.Context.SResult + -> rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + (ghc-internal:GHC.Internal.Data.Functor.Identity.Identity + x_a14xK))) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (toColumns x_a14xL)) + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gfromResult + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity x_a14xK)) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel x_a14xL)) + = TablePair + (ghc-internal:GHC.Internal.Data.Functor.Identity.runIdentity + x_a14xK) + (rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gfromResult + @TableTest x_a14xL) + rel8-1.6.0.0-inplace:Rel8.Generic.Rel8able.gtoResult + (TablePair x_a14xK x_a14xL) + = rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Product.HProduct + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Identity.HIdentity + (ghc-internal:GHC.Internal.Data.Functor.Identity.Identity + x_a14xK))) + (rel8-1.6.0.0-inplace:Rel8.Schema.HTable.Label.HLabel + (toResult (x_a14xL :: TableTest Result) :: + Columns (TableTest Result) Result)) diff --git a/tests/Rel8/Generic/Rel8able/Test.hs b/tests/Rel8/Generic/Rel8able/Test.hs index 04c57a29..9e89c5de 100644 --- a/tests/Rel8/Generic/Rel8able/Test.hs +++ b/tests/Rel8/Generic/Rel8able/Test.hs @@ -10,8 +10,11 @@ {-# language TypeFamilies #-} {-# language TypeOperators #-} {-# language UndecidableInstances #-} +{-# language TypeApplications #-} +{-# language InstanceSigs #-} +{-# language PartialTypeSignatures #-} -{-# options_ghc -O0 #-} +{-# options_ghc -O0 -ddump-simpl -ddump-to-file -ddump-ds -ddump-splices #-} module Rel8.Generic.Rel8able.Test ( module Rel8.Generic.Rel8able.Test @@ -34,6 +37,8 @@ data TableTest f = TableTest { foo :: Column f Bool , bar :: Column f (Maybe Bool) } + -- deriving stock Generic + -- deriving anyclass Rel8able deriveRel8able ''TableTest @@ -41,8 +46,11 @@ deriveRel8able ''TableTest data TablePair f = TablePair { foo :: Column f Bool - , bars :: (Column f Text, Column f Text) + -- , bars :: (Column f Text, Column f Text) + , bars :: TableTest f } + -- deriving stock Generic + -- deriving anyclass Rel8able deriveRel8able ''TablePair @@ -52,142 +60,144 @@ data TableMaybe f = TableMaybe { foo :: Column f [Maybe Bool] , bars :: HMaybe f (TablePair f, TablePair f) } - deriving stock Generic - deriving anyclass Rel8able + -- deriving stock Generic + -- deriving anyclass Rel8able +deriveRel8able ''TableMaybe -data TableEither f = TableEither - { foo :: Column f Bool - , bars :: HEither f (HMaybe f (TablePair f, TablePair f)) (Column f Char) - } - deriving stock Generic - deriving anyclass Rel8able +-- data TableEither f = TableEither +-- { foo :: Column f Bool +-- , bars :: HEither f (HMaybe f (TablePair f, TablePair f)) (Column f Char) +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able -data TableThese f = TableThese - { foo :: Column f Bool - , bars :: HThese f (TableMaybe f) (TableEither f) - } - deriving stock Generic - deriving anyclass Rel8able +-- data TableThese f = TableThese +-- { foo :: Column f Bool +-- , bars :: HThese f (TableMaybe f) (TableEither f) +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able -data TableList f = TableList - { foo :: Column f Bool - , bars :: HList f (TableThese f) - } - deriving stock Generic - deriving anyclass Rel8able +-- data TableList f = TableList +-- { foo :: Column f Bool +-- , bars :: HList f (TableThese f) +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able -data TableNonEmpty f = TableNonEmpty - { foo :: Column f Bool - , bars :: HNonEmpty f (TableList f, TableMaybe f) - } - deriving stock Generic - deriving anyclass Rel8able +-- data TableNonEmpty f = TableNonEmpty +-- { foo :: Column f Bool +-- , bars :: HNonEmpty f (TableList f, TableMaybe f) +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able -data TableNest f = TableNest - { foo :: Column f Bool - , bars :: HList f (HMaybe f (TablePair f)) - } - deriving stock Generic - deriving anyclass Rel8able +-- data TableNest f = TableNest +-- { foo :: Column f Bool +-- , bars :: HList f (HMaybe f (TablePair f)) +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able -data S3Object = S3Object - { bucketName :: Text - , objectKey :: Text - } - deriving stock Generic +-- data S3Object = S3Object +-- { bucketName :: Text +-- , objectKey :: Text +-- } +-- deriving stock Generic -instance x ~ HKD S3Object Expr => ToExprs x S3Object +-- instance x ~ HKD S3Object Expr => ToExprs x S3Object -data HKDSum = HKDSumA Text | HKDSumB Bool Char | HKDSumC - deriving stock Generic +-- data HKDSum = HKDSumA Text | HKDSumB Bool Char | HKDSumC +-- deriving stock Generic -instance x ~ HKD HKDSum Expr => ToExprs x HKDSum +-- instance x ~ HKD HKDSum Expr => ToExprs x HKDSum -data HKDTest f = HKDTest - { s3Object :: Lift f S3Object - , hkdSum :: Lift f HKDSum - } - deriving stock Generic - deriving anyclass Rel8able - - -data NonRecord f = NonRecord - (Column f Bool) - (Column f Char) - (Column f Char) - (Column f Char) - (Column f Char) - (Column f Char) - (Column f Char) - (Column f Char) - (Column f Char) - (Column f Char) - deriving stock Generic - deriving anyclass Rel8able - - -data TableSum f - = TableSumA (Column f Bool) (Column f Text) - | TableSumB - | TableSumC (Column f Text) - deriving stock Generic - - -data BarbieSum f - = BarbieSumA (f Bool) (f Text) - | BarbieSumB - | BarbieSumC (f Text) - deriving stock Generic - - -data TableProduct f = TableProduct - { sum :: HADT f BarbieSum - , list :: TableList f - , foos :: HList f (HADT f TableSum, Lift f HKDSum, HKDTest f) - } - deriving stock Generic - deriving anyclass Rel8able +-- data HKDTest f = HKDTest +-- { s3Object :: Lift f S3Object +-- , hkdSum :: Lift f HKDSum +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able -data TableTestB f = TableTestB - { foo :: f Bool - , bar :: f (Maybe Bool) - } - deriving stock Generic - deriving anyclass Rel8able +-- data NonRecord f = NonRecord +-- (Column f Bool) +-- (Column f Char) +-- (Column f Char) +-- (Column f Char) +-- (Column f Char) +-- (Column f Char) +-- (Column f Char) +-- (Column f Char) +-- (Column f Char) +-- (Column f Char) +-- deriving stock Generic +-- deriving anyclass Rel8able -data NestedTableTestB f = NestedTableTestB - { foo :: f Bool - , bar :: f (Maybe Bool) - , baz :: Column f Char - , nest :: TableTestB f - } - deriving stock Generic - deriving anyclass Rel8able +-- data TableSum f +-- = TableSumA (Column f Bool) (Column f Text) +-- | TableSumB +-- | TableSumC (Column f Text) +-- deriving stock Generic -newtype IdRecord a f = IdRecord { recordId :: Column f a } - deriving stock Generic +-- data BarbieSum f +-- = BarbieSumA (f Bool) (f Text) +-- | BarbieSumB +-- | BarbieSumC (f Text) +-- deriving stock Generic -instance DBType a => Rel8able (IdRecord a) +-- data TableProduct f = TableProduct +-- { sum :: HADT f BarbieSum +-- , list :: TableList f +-- , foos :: HList f (HADT f TableSum, Lift f HKDSum, HKDTest f) +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able -type Nest :: KRel8able -> KRel8able -> KRel8able -data Nest t u f = Nest - { foo :: t f - , bar :: u f - } - deriving stock Generic - deriving anyclass Rel8able + +-- data TableTestB f = TableTestB +-- { foo :: f Bool +-- , bar :: f (Maybe Bool) +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able + + +-- data NestedTableTestB f = NestedTableTestB +-- { foo :: f Bool +-- , bar :: f (Maybe Bool) +-- , baz :: Column f Char +-- , nest :: TableTestB f +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able + + +-- newtype IdRecord a f = IdRecord { recordId :: Column f a } +-- deriving stock Generic + + +-- instance DBType a => Rel8able (IdRecord a) + + +-- type Nest :: KRel8able -> KRel8able -> KRel8able +-- data Nest t u f = Nest +-- { foo :: t f +-- , bar :: u f +-- } +-- deriving stock Generic +-- deriving anyclass Rel8able diff --git a/treefmt.toml b/treefmt.toml new file mode 100644 index 00000000..b1c37c6e --- /dev/null +++ b/treefmt.toml @@ -0,0 +1,52 @@ +[formatter.cabal] +command = "cabal-fmt" +options = [ "--tabular", "-i" ] +includes = [ "*.cabal" ] +excludes = [] + +[formatter.elm] +command = "elm-format" +options = [ "--elm-version", "0.19", "--yes" ] +includes = [ "*.elm" ] +excludes = [ "client/elm-semantic-ui/*" ] + +[formatter.nix] +command = "nixpkgs-fmt" +options = [] +includes = ["*.nix"] +excludes = [ "factory-infrastructure/secrets/*.nix" ] + +[formatter.terraform] +command = "terraform" +options = ["fmt"] +includes = ["*.tf"] + +# A bit of a hack, but until https://github.com/numtide/treefmt/issues/77 is +# resolved we need to manually sequence our Haskell formatters. +[formatter.haskell] +command = "/bin/sh" +options = [ + "-euc", + """ +fourmolu -i "$@" +ch-hs-imports --overwrite --local-modules-from-current-dir --report-progress "$@" + """, + "format-haskell" +] +includes = [ "*.hs" ] + +excludes = [ + # These fail to parse + "ch-eda-all/ch-eda/src/CircuitHub/WebSockets.hs", + "basler/lib/Basler/Context.hs", +] + +[formatter.prettier] +command = "prettier" +options = [ "--write" ] +includes = [ "client/*.js", "client/*.css", "client/*.json", "picofactory/pallet-markup/client/main.js", "retool/**/*.tsx" ] +excludes = [ "client/semantic/*", "client/elm-semantic-ui/*", "client/js/lib/**/*.css" ] + +[formatter.black] +command = "black" +includes = [ "*.py" ]