-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | A database library with a focus on ease of use, type safety and useful error messages
--   
--   Please see README.md
@package data-basic
@version 0.3.0.0

module Internal.Data.Basic.TypeLevel
class AllSatisfy c (l :: [k])
mapTypeList :: AllSatisfy c l => proxy1 c -> (forall proxy2 (x :: k). c x => proxy2 x -> a) -> proxy3 l -> [a]
type CheckWithError (b :: Bool) (err :: ErrorMessage) = EqualOrError b  'True err
type ErrorText =  'Text
class c x => TypeSatisfies (c :: * -> Constraint) (x :: *) (field :: Symbol)
class CheckWithError (NotMaybe a) (FieldNullErr field) => NotNull (a :: *) (field :: Symbol)
class Trivial a

-- | A description of a custom type error.
data ErrorMessage :: *

-- | Pretty print the type. <tt>ShowType :: k -&gt; ErrorMessage</tt>
[ShowType] :: ErrorMessage

-- | Put two pieces of error message next to each other.
[:<>:] :: ErrorMessage

-- | Stack two pieces of error message on top of each other.
[:$$:] :: ErrorMessage

-- | The type-level equivalent of <tt>error</tt>.
--   
--   The polymorphic kind of this type allows it to be used in several
--   settings. For instance, it can be used as a constraint, e.g. to
--   provide a better error message for a non-existent instance,
--   
--   <pre>
--   -- in a context
--   instance TypeError (Text "Cannot <a>Show</a> functions." :$$:
--                       Text "Perhaps there is a missing argument?")
--         =&gt; Show (a -&gt; b) where
--       showsPrec = error "unreachable"
--   </pre>
--   
--   It can also be placed on the right-hand side of a type-level function
--   to provide an error for an invalid case,
--   
--   <pre>
--   type family ByteSize x where
--      ByteSize Word16   = 2
--      ByteSize Word8    = 1
--      ByteSize a        = TypeError (Text "The type " :&lt;&gt;: ShowType a :&lt;&gt;:
--                                     Text " is not exportable.")
--   </pre>
instance forall k (a :: k). Internal.Data.Basic.TypeLevel.Trivial a
instance c x => Internal.Data.Basic.TypeLevel.TypeSatisfies c x field
instance Internal.Data.Basic.TypeLevel.CheckWithError (Internal.Data.Basic.TypeLevel.NotMaybe a) (Internal.Data.Basic.TypeLevel.FieldNullErr field) => Internal.Data.Basic.TypeLevel.NotNull a field
instance forall k (c :: k -> GHC.Types.Constraint). Internal.Data.Basic.TypeLevel.AllSatisfy c '[]
instance forall a (c :: a -> GHC.Types.Constraint) (k :: a) (ks :: [a]). (c k, Internal.Data.Basic.TypeLevel.AllSatisfy c ks) => Internal.Data.Basic.TypeLevel.AllSatisfy c (k : ks)


-- | module Internal. : Data.Basic.TH.Types Description : Data types and
--   utility function used during TH generation phase Copyright : (c)
--   Nikola Henezi, 2016-2017 Luka Horvat, 2016-2017 License : MIT
--   
--   This module Internal.defines data types that are used during parsing
--   and TH generation stages. They describe structure of the parser and
--   define minimal representation that is needed from parser in order to
--   generate Template Haskell.
module Internal.Data.Basic.TH.Types

-- | When something goes wrong, this explains what went wrong -
--   hopefully...
data ParseError
ParseError :: Text -> ParseError

-- | List of constraints that can be applied to a Column and affect
--   generated datatype Currently, only Null constraint affects it by
--   wrapping data type with <a>Maybe</a>
data ColumnConstraint
NullConstraint :: ColumnConstraint
NotNullConstraint :: ColumnConstraint
DefaultConstraint :: ColumnConstraint

-- | Column information gathered from a parser
data ColumnInfo
ColumnInfo :: !Text -> !Text -> !Name -> !Type -> !TypeName -> ![ColumnConstraint] -> ColumnInfo

-- | name retrieved from the parser
[$sel:_columnInfoText:ColumnInfo] :: ColumnInfo -> !Text

-- | normalized name of the field
[$sel:_columnInfoNormalName:ColumnInfo] :: ColumnInfo -> !Text

-- | generate TH name
[$sel:_columnInfoName:ColumnInfo] :: ColumnInfo -> !Name

-- | generated TH type
[$sel:_columnInfoType:ColumnInfo] :: ColumnInfo -> !Type

-- | original sql type
[$sel:_columnInfoSqlType:ColumnInfo] :: ColumnInfo -> !TypeName

-- | list of constraints that have to be applied
[$sel:_columnInfoConstraints:ColumnInfo] :: ColumnInfo -> ![ColumnConstraint]
columnInfoType :: Lens' ColumnInfo Type
columnInfoText :: Lens' ColumnInfo Text
columnInfoSqlType :: Lens' ColumnInfo TypeName
columnInfoNormalName :: Lens' ColumnInfo Text
columnInfoName :: Lens' ColumnInfo Name
columnInfoConstraints :: Lens' ColumnInfo [ColumnConstraint]

-- | Entity information gathered from a parser
data EntityInfo
EntityInfo :: !Text -> !Name -> !Name -> !Type -> ![Constraint] -> [ColumnInfo] -> EntityInfo

-- | name retrieved from the parser, basically a computed value of
--   <a>Name</a>
[$sel:_entityInfoText:EntityInfo] :: EntityInfo -> !Text

-- | generated TH name
[$sel:_entityInfoName:EntityInfo] :: EntityInfo -> !Name

-- | original sql name retrieved by hssqlpp
[$sel:_entityInfoSQLName:EntityInfo] :: EntityInfo -> !Name

-- | generated datatype
[$sel:_entityInfoType:EntityInfo] :: EntityInfo -> !Type

-- | list of constraints that have to be applied
[$sel:_entityInfoConstraintList:EntityInfo] :: EntityInfo -> ![Constraint]

-- | list of all columns
[$sel:_entityInfoColumnMap:EntityInfo] :: EntityInfo -> [ColumnInfo]
entityInfoType :: Lens' EntityInfo Type
entityInfoText :: Lens' EntityInfo Text
entityInfoSQLName :: Lens' EntityInfo Name
entityInfoName :: Lens' EntityInfo Name
entityInfoConstraintList :: Lens' EntityInfo [Constraint]
entityInfoColumnMap :: Lens' EntityInfo [ColumnInfo]

-- | Minimal context we need to generate a foreign key constraint
data ForeignKeyConstraint
ForeignKeyConstraint :: !Text -> !EntityInfo -> ![ColumnInfo] -> !EntityInfo -> ![ColumnInfo] -> ForeignKeyConstraint

-- | name of the foreign key
[$sel:_fkName:ForeignKeyConstraint] :: ForeignKeyConstraint -> !Text
[$sel:_fkFromT:ForeignKeyConstraint] :: ForeignKeyConstraint -> !EntityInfo
[$sel:_fkFromCols:ForeignKeyConstraint] :: ForeignKeyConstraint -> ![ColumnInfo]

-- | referenced entity
[$sel:_fkToT:ForeignKeyConstraint] :: ForeignKeyConstraint -> !EntityInfo

-- | referenced columns
[$sel:_fkToCols:ForeignKeyConstraint] :: ForeignKeyConstraint -> ![ColumnInfo]
fkToT :: Lens' ForeignKeyConstraint EntityInfo
fkToCols :: Lens' ForeignKeyConstraint [ColumnInfo]
fkName :: Lens' ForeignKeyConstraint Text
fkFromT :: Lens' ForeignKeyConstraint EntityInfo
fkFromCols :: Lens' ForeignKeyConstraint [ColumnInfo]

-- | Minimal context we need to generate a unique key constraint
data UniqueKeyConstraint
UniqueKeyConstraint :: !Text -> !EntityInfo -> ![ColumnInfo] -> UniqueKeyConstraint

-- | name of the constraint
[$sel:_uqName:UniqueKeyConstraint] :: UniqueKeyConstraint -> !Text

-- | referenced entity
[$sel:_uqEntity:UniqueKeyConstraint] :: UniqueKeyConstraint -> !EntityInfo

-- | referenced columns
[$sel:_uqCols:UniqueKeyConstraint] :: UniqueKeyConstraint -> ![ColumnInfo]
uqName :: Lens' UniqueKeyConstraint Text
uqEntity :: Lens' UniqueKeyConstraint EntityInfo
uqCols :: Lens' UniqueKeyConstraint [ColumnInfo]

-- | Minimal context we need to generate a primary key constraint
data PrimaryKeyConstraint
PrimaryKeyConstraint :: !Text -> !EntityInfo -> ![ColumnInfo] -> PrimaryKeyConstraint

-- | name of the constraint
[$sel:_pkName:PrimaryKeyConstraint] :: PrimaryKeyConstraint -> !Text

-- | referenced entity
[$sel:_pkEntity:PrimaryKeyConstraint] :: PrimaryKeyConstraint -> !EntityInfo

-- | referenced columns
[$sel:_pkCols:PrimaryKeyConstraint] :: PrimaryKeyConstraint -> ![ColumnInfo]
pkName :: Lens' PrimaryKeyConstraint Text
pkEntity :: Lens' PrimaryKeyConstraint EntityInfo
pkCols :: Lens' PrimaryKeyConstraint [ColumnInfo]

-- | Full parse context. This datatype is filled with information as parser
--   goes trough the sql file. After <a>ParseContext</a> is filled, TH
--   takes over and code generation starts.
data ParseContext
ParseContext :: ![EntityInfo] -> ![ForeignKeyConstraint] -> ![PrimaryKeyConstraint] -> ![UniqueKeyConstraint] -> ParseContext

-- | list of entities found
[$sel:_entities:ParseContext] :: ParseContext -> ![EntityInfo]

-- | all foreign keys
[$sel:_fks:ParseContext] :: ParseContext -> ![ForeignKeyConstraint]

-- | all primary keys
[$sel:_pks:ParseContext] :: ParseContext -> ![PrimaryKeyConstraint]

-- | all unique constraints
[$sel:_uqs:ParseContext] :: ParseContext -> ![UniqueKeyConstraint]
uqs :: Lens' ParseContext [UniqueKeyConstraint]
pks :: Lens' ParseContext [PrimaryKeyConstraint]
fks :: Lens' ParseContext [ForeignKeyConstraint]
entities :: Lens' ParseContext [EntityInfo]

-- | Defines null values for all datatypes that we support in Basic. This
--   is basically a hack to avoid usage of unsafeCoerce, because with
--   unsafeCoerce you can hit segmentation faults due to wrong memory
--   allocation (e.g. <a>Int</a> and <a>Bool</a>).
class NullValue a
nullValue :: NullValue a => a
newtype Schema
Schema :: Text -> Schema
instance Internal.Data.Basic.TH.Types.NullValue GHC.Types.Int
instance Internal.Data.Basic.TH.Types.NullValue GHC.Types.Bool
instance Internal.Data.Basic.TH.Types.NullValue Data.Time.LocalTime.Internal.LocalTime.LocalTime
instance Internal.Data.Basic.TH.Types.NullValue Data.Time.LocalTime.Internal.TimeOfDay.TimeOfDay
instance (Internal.Data.Basic.TH.Types.NullValue a, Internal.Data.Basic.TH.Types.NullValue b) => Internal.Data.Basic.TH.Types.NullValue (a, b)
instance Internal.Data.Basic.TH.Types.NullValue GHC.Types.Double
instance Internal.Data.Basic.TH.Types.NullValue Data.Text.Internal.Text
instance Internal.Data.Basic.TH.Types.NullValue Data.Scientific.Scientific
instance Internal.Data.Basic.TH.Types.NullValue Data.Time.Calendar.Days.Day
instance Internal.Data.Basic.TH.Types.NullValue Data.ByteString.Internal.ByteString
instance Internal.Data.Basic.TH.Types.NullValue (GHC.Base.Maybe a)
instance Data.Semigroup.Semigroup Internal.Data.Basic.TH.Types.ParseContext
instance GHC.Base.Monoid Internal.Data.Basic.TH.Types.ParseContext
instance GHC.Show.Show Internal.Data.Basic.TH.Types.ParseContext
instance GHC.Show.Show Internal.Data.Basic.TH.Types.PrimaryKeyConstraint
instance GHC.Show.Show Internal.Data.Basic.TH.Types.UniqueKeyConstraint
instance GHC.Show.Show Internal.Data.Basic.TH.Types.ForeignKeyConstraint
instance GHC.Show.Show Internal.Data.Basic.TH.Types.EntityInfo
instance GHC.Classes.Eq Internal.Data.Basic.TH.Types.EntityInfo
instance GHC.Classes.Eq Internal.Data.Basic.TH.Types.ColumnInfo
instance GHC.Show.Show Internal.Data.Basic.TH.Types.ColumnInfo
instance GHC.Classes.Eq Internal.Data.Basic.TH.Types.ColumnConstraint
instance GHC.Show.Show Internal.Data.Basic.TH.Types.ColumnConstraint
instance GHC.Show.Show Internal.Data.Basic.TH.Types.ParseError
instance Data.Semigroup.Semigroup Internal.Data.Basic.TH.Types.ParseError
instance GHC.Base.Monoid Internal.Data.Basic.TH.Types.ParseError


-- | module Internal. : Data.Basic.TH.Types Description : Data types and
--   utility function used during TH generation phase License : MIT
--   
--   This module Internal.contains helper functions that are used in code
--   generation process.
module Internal.Data.Basic.TH.Helper
type Throws e = MonadEffect (Signal e Void)
liftError :: Throws ParseError m => Either ParseErrorExtra a -> m a

-- | lifts a list of types to a type level (i.e. typelevel list) e.g.
--   `listToTypeLeve [Int, String, Double] = '[ Int, String, Double ]`
listToTypeLevel :: [Type] -> Type

-- | Used to append n times `<a>$</a> field` to the expression
addFields :: Exp -> Int -> Exp

-- | Used to append `<a>$</a> field` at the end of the expression
addField :: Exp -> Exp

-- | returns a plural of a known noun. Basically just appends <tt>s</tt> or
--   <tt>es</tt>
quasyPlural :: Text -> Text

-- | Tries to name multiples constraints
nameUnnamedConstraints :: Throws ParseError m => EntityInfo -> m EntityInfo

-- | Mechanism for naming unnamed constraints. If a constraint cannot be
--   named, an error is trown
nameUnnamedConstraint :: Throws ParseError m => EntityInfo -> Constraint -> m Constraint

-- | Provides default naming scheme for constraints
nameConstraint :: Text -> [NameComponent] -> Text

-- | Converts a <a>Name</a> to a plain text @TODO test complex naming
--   schemes
getName :: Name -> Text

-- | Retrieves a list of optional columns in an entity
getDynamicDefaultColumns :: ParseContext -> EntityInfo -> [ColumnInfo]

-- | Tries to retrieve entity information. If an entity with that name
--   doesn't exist an error is thrown.
getEntityByName :: Throws ParseError m => Name -> [EntityInfo] -> m EntityInfo

-- | Tries to retrieve entity information. If an entity with that name
--   doesn't exist an error is thrown.
getEntityBySQLName :: Throws ParseError m => Name -> [EntityInfo] -> m EntityInfo

-- | Tries to retrieve column information from entity. If a column with
--   that name doesn't exist an error is thrown.
getColumn :: Throws ParseError m => EntityInfo -> Text -> m ColumnInfo
lowerFirst :: Text -> Text
upperFirst :: Text -> Text

-- | Converts camel case or snake case to normal form. Examples:
--   
--   <pre>
--   normalizeName "ABCDE"
--   </pre>
--   
--   "abcde" &gt; normalizeName <a>ABC_DE</a> "abcDe" &gt; normalizeName
--   <a>AbcDe</a> "abcDe" &gt; normalizeName "abcDe" "abcDe" &gt;
--   normalizeName "abcde" "abcde"
normalizeName :: Text -> Text
normalizeTable :: Text -> Text

-- | Retrieves the primary key for an entity from <a>ParseContext</a>
getEntityPrimaryKey :: ParseContext -> EntityInfo -> Maybe PrimaryKeyConstraint

-- | Generates name for the column lens (i.e. lowercases first letter)
columnNameToLensName :: Text -> Text


-- | Conversion between Postgres types and haskell datatypes. As a starting
--   point, <tt>fromField</tt> from Database.PostgreSQL.Simple.FromField is
--   used. If you need support for additional datatypes, please open an
--   issue (https:/<i>gitlab.com</i>haskell-hr/basic) or email maintainers
module Internal.Data.Basic.TH.SqlToHsTypes

-- | Conversion between <a>TypeName</a> to haskell <a>Type</a>.
--   <a>TypeName</a> is used internaly by <a>HsSqlPpp</a>
toHsType :: Throws ParseError m => TypeName -> m (Type, [ColumnConstraint])

module Internal.Data.Basic.SqlToHsTypes
data Point
Point :: {-# UNPACK #-} !Double -> {-# UNPACK #-} !Double -> Point
instance Data.Aeson.Types.FromJSON.FromJSON Internal.Data.Basic.SqlToHsTypes.Point
instance Data.Aeson.Types.ToJSON.ToJSON Internal.Data.Basic.SqlToHsTypes.Point
instance GHC.Generics.Generic Internal.Data.Basic.SqlToHsTypes.Point
instance GHC.Show.Show Internal.Data.Basic.SqlToHsTypes.Point
instance GHC.Read.Read Internal.Data.Basic.SqlToHsTypes.Point
instance GHC.Classes.Eq Internal.Data.Basic.SqlToHsTypes.Point
instance Database.PostgreSQL.Simple.FromField.FromField Internal.Data.Basic.SqlToHsTypes.Point
instance Database.PostgreSQL.Simple.ToField.ToField Internal.Data.Basic.SqlToHsTypes.Point

module Internal.Data.Basic.Sql.Types
data QuerySegment
QuerySegment :: Query -> [Action] -> QuerySegment
data Comparison
LessThan :: Comparison
LessOrEqual :: Comparison
GreaterThan :: Comparison
GreaterOrEqual :: Comparison
Equal :: Comparison
NotEqual :: Comparison
data SortDirection
Ascending :: SortDirection
Descending :: SortDirection
newtype SqlFunctionName
SqlFunctionName :: Text -> SqlFunctionName
data QualifiedField
QualifiedField :: Int -> Text -> QualifiedField
newtype TableValue
TableValue :: Int -> TableValue
data QualifiedTable
QualifiedTable :: Text -> Int -> QualifiedTable
data Condition
SqlAnd :: Condition -> Condition -> Condition
SqlOr :: Condition -> Condition -> Condition
SqlOperator :: Comparison -> SqlValueExp -> SqlValueExp -> Condition
IsNull :: SqlValueExp -> Condition
IsNotNull :: SqlValueExp -> Condition
In :: SqlValueExp -> [SqlValueExp] -> Condition
BoolLit :: Bool -> Condition
Like :: Bool -> SqlValueExp -> Text -> Condition
data AggregateFunction
Avg :: AggregateFunction
Max :: AggregateFunction
Min :: AggregateFunction
Count :: AggregateFunction
Sum :: AggregateFunction
Only :: AggregateFunction
ArrayAgg :: AggregateFunction
data SqlValueExp
SimpleName :: QualifiedField -> SqlValueExp
TableRecord :: TableValue -> SqlValueExp
SqlFunctionApplication :: SqlFunctionName -> SqlValueExp -> SqlValueExp
SqlLiteral :: Action -> SqlValueExp
AggregateFunction :: AggregateFunction -> SqlValueExp -> SqlValueExp
newtype Limit
Limit :: (Maybe Int) -> Limit
data Selection
SelectEverything :: Selection
SelectExpressions :: [SqlValueExp] -> Selection
newtype Grouping
Grouping :: [SqlValueExp] -> Grouping
data SqlExp
Select :: Selection -> (Maybe Condition) -> [QualifiedTable] -> [(SqlValueExp, SortDirection)] -> Limit -> Grouping -> SqlExp
Insert :: Text -> [Text] -> [Action] -> SqlExp
RawQuery :: Text -> [Action] -> SqlExp
Delete :: QualifiedTable -> (Maybe Condition) -> SqlExp
Update :: [Text] -> [SqlValueExp] -> (Maybe Condition) -> QualifiedTable -> SqlExp
sToQuery :: StringConv a ByteString => a -> QuerySegment
actionToQuery :: Action -> QuerySegment
tableToQuery :: QualifiedTable -> QuerySegment
comparisonToQuery :: Comparison -> QuerySegment
fieldToQuery :: QualifiedField -> QuerySegment
tableValueToQuery :: TableValue -> QuerySegment
aggregateFunctionToQuery :: AggregateFunction -> QuerySegment
valueToQuery :: SqlValueExp -> QuerySegment
conditionToQuery :: Condition -> QuerySegment
orderingToQuery :: (SqlValueExp, SortDirection) -> QuerySegment
limitToQuery :: Limit -> QuerySegment
selectionToQuery :: Selection -> QuerySegment
groupToQuery :: Grouping -> QuerySegment
listToTuple :: [QuerySegment] -> QuerySegment
separateBy :: (Monoid a, Semigroup a, IsString a) => a -> [a] -> a
sqlExpToQuery :: SqlExp -> QuerySegment
data SqlResult
SqlResult :: [a] -> SqlResult
data SomeFromRowProxy
SomeFromRowProxy :: (Proxy a) -> SomeFromRowProxy
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.SqlExp
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.Grouping
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.Selection
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.Limit
instance GHC.Read.Read Internal.Data.Basic.Sql.Types.Limit
instance GHC.Classes.Ord Internal.Data.Basic.Sql.Types.Limit
instance GHC.Classes.Eq Internal.Data.Basic.Sql.Types.Limit
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.Condition
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.SqlValueExp
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.AggregateFunction
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.QualifiedTable
instance GHC.Read.Read Internal.Data.Basic.Sql.Types.QualifiedTable
instance GHC.Classes.Ord Internal.Data.Basic.Sql.Types.QualifiedTable
instance GHC.Classes.Eq Internal.Data.Basic.Sql.Types.QualifiedTable
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.TableValue
instance GHC.Read.Read Internal.Data.Basic.Sql.Types.TableValue
instance GHC.Classes.Ord Internal.Data.Basic.Sql.Types.TableValue
instance GHC.Classes.Eq Internal.Data.Basic.Sql.Types.TableValue
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.QualifiedField
instance GHC.Read.Read Internal.Data.Basic.Sql.Types.QualifiedField
instance GHC.Classes.Ord Internal.Data.Basic.Sql.Types.QualifiedField
instance GHC.Classes.Eq Internal.Data.Basic.Sql.Types.QualifiedField
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.SqlFunctionName
instance GHC.Read.Read Internal.Data.Basic.Sql.Types.SqlFunctionName
instance GHC.Classes.Ord Internal.Data.Basic.Sql.Types.SqlFunctionName
instance GHC.Classes.Eq Internal.Data.Basic.Sql.Types.SqlFunctionName
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.SortDirection
instance GHC.Read.Read Internal.Data.Basic.Sql.Types.SortDirection
instance GHC.Classes.Ord Internal.Data.Basic.Sql.Types.SortDirection
instance GHC.Classes.Eq Internal.Data.Basic.Sql.Types.SortDirection
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.Comparison
instance GHC.Read.Read Internal.Data.Basic.Sql.Types.Comparison
instance GHC.Classes.Ord Internal.Data.Basic.Sql.Types.Comparison
instance GHC.Classes.Eq Internal.Data.Basic.Sql.Types.Comparison
instance GHC.Show.Show Internal.Data.Basic.Sql.Types.QuerySegment
instance Data.Semigroup.Semigroup Internal.Data.Basic.Sql.Types.Condition
instance GHC.Base.Monoid Internal.Data.Basic.Sql.Types.QuerySegment
instance Data.Semigroup.Semigroup Internal.Data.Basic.Sql.Types.QuerySegment
instance Data.String.IsString Internal.Data.Basic.Sql.Types.QuerySegment
instance Data.Semigroup.Semigroup Database.PostgreSQL.Simple.Types.Query


-- | Decode postgresql composites into entities Adapted code from:
--   <a>https://hackage.haskell.org/package/postgresql-simple-0.4.10.0/docs/src/Database-PostgreSQL-Simple-Arrays.html</a>
module Internal.Composite
data Composite (ts :: [*])
[EmptyComposite] :: Composite '[]
[ConsComposite] :: t -> Composite ts -> Composite (t : ts)

-- | any postgresql composite type whose fields are compatible with types
--   <tt>ts</tt>
pgCompositeFieldParser :: FieldParsers ts => FieldParser (Composite ts)
class Typeable ts => FieldParsers ts
fromCompositeFormats :: FieldParsers ts => [TypeInfo] -> Field -> [CompositeFormat] -> Conversion (Composite ts)
fromComposite :: FieldParsers ts => TypeInfo -> Field -> Parser (Conversion (Composite ts))
compositeFormat :: Parser CompositeFormat
data CompositeFormat
Plain :: ByteString -> CompositeFormat
Quoted :: ByteString -> CompositeFormat
NullStr :: CompositeFormat
composite :: Parser [CompositeFormat]
quoted :: Parser ByteString
plain :: Parser ByteString
fmt :: CompositeFormat -> ByteString
delimit :: [CompositeFormat] -> ByteString
fmt' :: Bool -> CompositeFormat -> ByteString
esc :: ByteString -> ByteString
instance GHC.Classes.Ord Internal.Composite.CompositeFormat
instance GHC.Show.Show Internal.Composite.CompositeFormat
instance GHC.Classes.Eq Internal.Composite.CompositeFormat
instance Internal.Composite.FieldParsers ts => Database.PostgreSQL.Simple.FromField.FromField (Internal.Composite.Composite ts)
instance Internal.Composite.FieldParsers '[]
instance (Database.PostgreSQL.Simple.FromField.FromField t, Data.Typeable.Internal.Typeable t, Internal.Composite.FieldParsers ts) => Internal.Composite.FieldParsers (t : ts)
instance GHC.Show.Show (Internal.Composite.Composite '[])
instance (GHC.Show.Show (Internal.Composite.Composite ts), GHC.Show.Show t) => GHC.Show.Show (Internal.Composite.Composite (t : ts))

module Internal.Data.Basic.Types
data VarContext
Filtering :: VarContext
Updating :: VarContext
Sorting :: VarContext
Grouping :: VarContext
Folding :: VarContext
Mapping :: VarContext
newtype Var (ctx :: VarContext) (a :: *)
Var :: Int -> Var
newtype Key
Key :: Int -> Key

-- | Defines <a>MissingField</a> kind.
data MissingField
Required :: Symbol -> MissingField
DynamicDefault :: Symbol -> MissingField
data Cached
Live :: Cached
Cached :: Cached
data EntityKind
Fresh :: [MissingField] -> EntityKind
FromDb :: Cached -> EntityKind
newtype Entity (entKind :: EntityKind) a
Entity :: a -> Entity a
[$sel:_getEntity:Entity] :: Entity a -> a
getEntity :: forall entKind_aJAl a_aJAm entKind_aJSj a_aJSk. Iso (Entity entKind_aJAl a_aJAm) (Entity entKind_aJSj a_aJSk) a_aJAm a_aJSk
toFreshEntity :: forall fs c a. Entity ( 'FromDb c) a -> Entity ( 'Fresh fs) a
reorderMissingFieldsTo :: forall fs2 fs1 a. SetEqual fs1 fs2 => Entity ( 'Fresh fs1) a -> Entity ( 'Fresh fs2) a
data FieldConstraint
Unique :: Symbol -> FieldConstraint
ForeignKey :: Symbol -> FieldConstraint
type SetFields (missing :: [MissingField]) (table :: *) = TableFields table `Without` MissingFieldsNames missing
class (KnownSymbol (CapsName t s)) => HasCapsFieldName t (s :: Symbol)
capsFieldName :: HasCapsFieldName t s => proxy s -> Text
class (AllSatisfy (TableField table) fields) => AllTypesSatisfy (c :: * -> Symbol -> Constraint) (table :: *) (fields :: [Symbol])
mapFields :: (AllTypesSatisfy c table fields, (fields `IsSubset` SetFields (MissingFields entKind) table)) => (forall proxy n x. c x n => proxy n -> x -> a) -> Entity entKind table -> [a]
class (KnownSymbol n, ToJSON a) => JSONableField a (n :: Symbol)
class GetEntityFromValue (fs :: [Symbol]) a where {
    type family MissingFieldsFromValue fs a :: [MissingField];
}
getEntityFromObject :: GetEntityFromValue fs a => Value -> Parser (Entity ( 'Fresh (MissingFieldsFromValue fs a)) a)
class (TableField table field, Ord (TableFieldType table field)) => OrdableField table field
class (TableField table field, Eq (TableFieldType table field)) => EqableField table field
class TableFieldTypes a fs ~ ts => FoldCompositeIntoEntity fs ts a
foldCompositeIntoEntity :: FoldCompositeIntoEntity fs ts a => Entity entKind a -> Composite ts -> Entity ( 'Fresh '[]) a
compositeToEntity :: forall a fs ts. (fs ~ TableFields a, ts ~ TableFieldTypes a fs, FoldCompositeIntoEntity fs ts a, Table a) => Composite ts -> Entity ( 'Fresh '[]) a
class (KnownSymbol (TableName table), AllSatisfy (TableField table) (TableFields table), AllSatisfy KnownSymbol (TableFields table), AllSatisfy (ValidConstraint table) (TableConstraints table), AllTypesSatisfy (TypeSatisfies ToField) table (TableFields table), OnMaybe (() :: Constraint) PrimaryKeyConstraint (TablePrimaryKey table), FromRow table) => Table table where {
    type family TableName table = (name :: Symbol) | name -> table;
    type family TableFields table :: [Symbol];
    type family TableConstraints table :: [FieldConstraint];
    type family TablePrimaryKey table :: Maybe Symbol;
    type family TableRequiredFields table :: [MissingField];
}
newEntity :: Table table => Entity ( 'Fresh (TableRequiredFields table)) table
class ValidConstraint (table :: *) (constr :: FieldConstraint)
getDbFields :: forall table. Table table => [Text]
class ValueAsDbExp' (IsDbExp a) a b => ValueAsDbExp a b
valueAsDbExp :: ValueAsDbExp a b => a -> DbExp (KindOfDbExp a) b
class ValueAsDbExp' (isDbExp :: Bool) a b
valueAsDbExp' :: ValueAsDbExp' isDbExp a b => a -> DbExp (KindOfDbExp a) b
class (KnownSymbol name, KnownSymbol (CapsName table name), IsDbExp (TableFieldType table name) ~  'False) => TableField (table :: *) (name :: Symbol) where {
    type family TableFieldType table name :: *;
    type family TableFieldCapsName table name :: Maybe Symbol;
    type TableFieldCapsName table name =  'Nothing;
}
tableFieldLens :: TableField table name => Lens' table (TableFieldType table name)
class (UniqueConstraint name, AllTypesSatisfy NotNull (UniqueTable name) (UniqueFields name)) => PrimaryKeyConstraint (name :: Symbol)
class (AllSatisfy (TableField (UniqueTable name)) (UniqueFields name), KnownSymbol name) => UniqueConstraint (name :: Symbol) where {
    type family UniqueTable name :: *;
    type family UniqueFields name :: [Symbol];
}
class (KnownSymbol name, AllSatisfy (TableField (ForeignKeyFrom name)) (ForeignKeyFromFields name), AllSatisfy (TableField (ForeignKeyTo name)) (ForeignKeyToFields name), SameTypes (ForeignKeyTo name) (ForeignKeyToFields name) (ForeignKeyFrom name) (ForeignKeyFromFields name)) => ForeignKeyConstraint (name :: Symbol) where {
    type family ForeignKeyFrom name :: *;
    type family ForeignKeyTo name :: *;
    type family ForeignKeyFromFields name :: [Symbol];
    type family ForeignKeyToFields name :: [Symbol];
}
type CanInsert entKind table = (Table table, CanInsertFresh (MissingFields entKind) table)
type CanInsertFresh (missing :: [MissingField]) (table :: *) = (CanInsertMissing missing, SetFields missing table `IsSubset` SetFields missing table, AllSatisfy (HasCapsFieldName table) (SetFields missing table), AllTypesSatisfy (TypeSatisfies ToField) table (SetFields missing table))
type CanUpdate table pk = (KnownSymbol pk, Table table, SetFields '[] table `IsSubset` SetFields '[] table)
type DbResult list = ListToTuple (Entity ( 'FromDb  'Live)) list
type Variables ctx list = ListToTuple (Var ctx) list
class TableSetVars ctx (tables :: [*])
makeVars :: TableSetVars ctx tables => Variables ctx tables
data BoolOp
And :: BoolOp
Or :: BoolOp
data ResultType
Filtered :: ResultType
Unfiltered :: ResultType
Inserted :: ResultType
Deleted :: ResultType
Updated :: ResultType
Sorted :: ResultType
Limited :: ResultType
Grouped :: ResultType
Mapped :: ResultType
Folded :: ResultType
RawQueried :: ResultType
type FieldIsGettableBool field missing = Not (field `Elem` MissingFieldsNames missing)
type FieldIsGettable field missing = CheckWithError (FieldIsGettableBool field missing) ((ErrorText "Field " :<>:  'ShowType field) :<>: ErrorText " is not set")
type FieldIsNotSet field setFields = CheckWithError (Not (Elem field setFields)) ((ErrorText "Cannot update the field " :<>:  'ShowType field) :<>: ErrorText " because it's already updated in this expression")
varFromUpdateExp :: UpdateExp fields t -> Var  'Updating t
type FlattenTuple t = ListToSimpleTuple (TupleToList t)
data DbStatement (resultType :: ResultType) (ts :: [*])
[Table] :: Table table => proxy (TableName table) -> DbStatement  'Unfiltered '[table]
[Filter] :: (TableSetVars  'Filtering tables, Selection f) => (Variables  'Filtering tables -> ConditionExp) -> DbStatement f tables -> DbStatement  'Filtered tables
[Join] :: DbStatement  'Unfiltered tables1 -> DbStatement  'Unfiltered tables2 -> DbStatement  'Unfiltered (tables1 ++ tables2)
[Raw] :: ToRow r => Text -> r -> DbStatement  'RawQueried a
[Execute] :: ToRow r => Text -> r -> DbStatement  'RawQueried '[]
[Insert] :: CanInsert missing table => Entity missing table -> DbStatement  'Inserted '[table]
[Delete] :: (Selection f, Table table) => DbStatement f '[table] -> DbStatement  'Deleted '[table]
[Update] :: (Selection f) => (Var  'Updating table -> UpdateExp fields table) -> DbStatement f '[table] -> DbStatement  'Updated '[a]
[SortOn] :: (Selection f, TableSetVars  'Sorting tables, Sortable ord) => (Variables  'Sorting tables -> ord) -> DbStatement f tables -> DbStatement  'Sorted tables
[Take] :: CanTake f => Int -> DbStatement f tables -> DbStatement  'Limited tables
[Map] :: (Mappable map, CanMap f, TableSetVars  'Mapping tables) => (Variables  'Mapping tables -> map) -> DbStatement f tables -> DbStatement  'Mapped '[MapResult map]
[AsGroup] :: TableSetVars  'Grouping tables => DbStatement f tables -> DbStatement  'Grouped tables
[GroupMap] :: GroupMappable map => ((AsAggregate group, DbStatement  'Grouped tables) -> map) -> GroupStatement group tables -> DbStatement  'Folded '[GroupMapResult map]
data GroupStatement group tables
[GroupOn] :: (Selection f, TableSetVars  'Grouping tables, Groupable group) => (Variables  'Grouping tables -> group) -> DbStatement f tables -> GroupStatement group tables

-- | A kind and type used so LiftAggregation can differentiate types like
--   `m a` from <a>AggregateStatement</a> by their kind.
data AM
AM :: AM
data AggregateStatement aggr (marker :: AM)
[Aggregate] :: (Aggregatable aggr, CanAggregate f, TableSetVars  'Folding tables) => (Variables  'Folding tables -> aggr) -> DbStatement f tables -> AggregateStatement aggr  'AM
data UpdateExp (fields :: [Symbol]) (table :: *)
[NoUpdate] :: Var  'Updating table -> UpdateExp '[] table
[SetField] :: (TableField table fieldName, FieldIsNotSet fieldName fields) => proxy fieldName -> UpdateExp fields table -> DbExp k (TableFieldType table fieldName) -> UpdateExp (fieldName : fields) table
data ConditionExp
[Compare] :: Ord a => Comparison -> DbExp k1 a -> DbExp k2 a -> ConditionExp
[BoolOp] :: BoolOp -> ConditionExp -> ConditionExp -> ConditionExp
[IsNull] :: DbExp  'FieldExp (Maybe a) -> ConditionExp
[IsNotNull] :: DbExp  'FieldExp (Maybe a) -> ConditionExp
[In] :: LiteralCollection collection a => DbExp k a -> collection -> ConditionExp
[Like] :: Bool -> DbExp  'FieldExp Text -> Text -> ConditionExp
[BoolLit] :: Bool -> ConditionExp
data ExpressionKind
FieldExp :: ExpressionKind
LiteralExp :: ExpressionKind
data DbExp (kind :: ExpressionKind) a
[Field] :: TableField table fieldName => proxy1 table -> proxy2 fieldName -> Var anyCtx table -> DbExp  'FieldExp (TableFieldType table fieldName)
[Literal] :: ToField a => a -> DbExp  'LiteralExp a
data SomeDbExp
[SomeDbExp] :: DbExp k a -> SomeDbExp
[SomeVar] :: Var k a -> SomeDbExp
class Sortable ord
getOrdering :: Sortable ord => ord -> [(SomeDbExp, SortDirection)]
class LiteralCollection collection a | collection -> a
getLiteralCollection :: LiteralCollection collection a => collection -> [SomeDbExp]
class Groupable group where {
    type family AsAggregate group :: *;
}
getGrouping :: Groupable group => group -> [SomeDbExp]
asAggregate :: Groupable group => group -> AsAggregate group
data GroupMappableThing res (am :: AM)
[GroupMappableDbExp] :: DbExp k a -> GroupMappableThing a  'AM
[GroupMappableVar] :: Var k a -> GroupMappableThing (Entity ( 'FromDb  'Live) a)  'AM
[GroupMappableAggr] :: Aggregatable aggr => AggregateStatement aggr  'AM -> GroupMappableThing (AggregationResult aggr)  'AM
class GroupMappableBase map
getGroupMappingBase :: GroupMappableBase map => map -> [(AggregateFunction, SomeDbExp)]
class GroupMappable map
getGroupMapping :: GroupMappable map => map -> [(AggregateFunction, SomeDbExp)]

-- | So dfoldMap knows to behave like an expression when used inside of a
--   dmap
class MappableBase map where {
    type family MapResultBase map :: *;
}
getMappingBase :: MappableBase map => map -> [SomeDbExp]
class Mappable map
getMapping :: Mappable map => map -> [SomeDbExp]
getAggr :: AggregateStatement aggr  'AM -> aggr
newtype Avg a
Avg :: a -> Avg a
newtype Count a
Count :: a -> Count a
newtype Only a
Only :: a -> Only a
newtype List a
List :: a -> List a
class AggregatableBase aggr where {
    type family AggregationBaseResult aggr :: *;
}
getAggregatingBase :: AggregatableBase aggr => aggr -> (AggregateFunction, SomeDbExp)
class Aggregatable aggr
getAggregating :: Aggregatable aggr => aggr -> [(AggregateFunction, SomeDbExp)]
nameText :: forall name. KnownSymbol name => Text
newtype Max a :: * -> *
Max :: a -> Max a
[getMax] :: Max a -> a
newtype Min a :: * -> *
Min :: a -> Min a
[getMin] :: Min a -> a

-- | Monoid under addition.
newtype Sum a :: * -> *
Sum :: a -> Sum a
[getSum] :: Sum a -> a
instance GHC.Show.Show Internal.Data.Basic.Types.BoolOp
instance GHC.Read.Read Internal.Data.Basic.Types.BoolOp
instance GHC.Classes.Ord Internal.Data.Basic.Types.BoolOp
instance GHC.Classes.Eq Internal.Data.Basic.Types.BoolOp
instance Internal.Data.Basic.Types.Groupable (Internal.Data.Basic.Types.DbExp k a)
instance (Internal.Data.Basic.Types.Table a, Internal.Data.Basic.Types.TablePrimaryKey a ~ 'GHC.Base.Just pk, Internal.Data.Basic.TypeLevel.AllSatisfy (Internal.Data.Basic.Types.TableField a) (Internal.Data.Basic.Types.UniqueFields pk)) => Internal.Data.Basic.Types.Groupable (Internal.Data.Basic.Types.Var 'Internal.Data.Basic.Types.Grouping a)
instance Internal.Data.Basic.Types.GroupMappableThing res 'Internal.Data.Basic.Types.AM ~ a => Internal.Data.Basic.Types.GroupMappableBase a
instance (Internal.Data.Basic.Types.AggregatableBase a, Internal.Data.Basic.Types.AggregatableBase b) => Internal.Data.Basic.Types.Aggregatable (a, b)
instance (Internal.Data.Basic.Types.AggregatableBase a, Internal.Data.Basic.Types.AggregatableBase b, Internal.Data.Basic.Types.AggregatableBase c) => Internal.Data.Basic.Types.Aggregatable (a, b, c)
instance Internal.Data.Basic.Types.AggregatableBase a => Internal.Data.Basic.Types.Aggregatable a
instance Internal.Data.Basic.Types.BadAggregateBaseError => Internal.Data.Basic.Types.AggregatableBase a
instance GHC.Classes.Ord a => Internal.Data.Basic.Types.AggregatableBase (Data.Semigroup.Max (Internal.Data.Basic.Types.DbExp f a))
instance GHC.Classes.Ord a => Internal.Data.Basic.Types.AggregatableBase (Data.Semigroup.Min (Internal.Data.Basic.Types.DbExp f a))
instance GHC.Num.Num a => Internal.Data.Basic.Types.AggregatableBase (Internal.Data.Basic.Types.Avg (Internal.Data.Basic.Types.DbExp f a))
instance Internal.Data.Basic.Types.AggregatableBase (Internal.Data.Basic.Types.Count (Internal.Data.Basic.Types.DbExp f a))
instance GHC.Num.Num a => Internal.Data.Basic.Types.AggregatableBase (Data.Monoid.Sum (Internal.Data.Basic.Types.DbExp f a))
instance Internal.Data.Basic.Types.AggregatableBase (Internal.Data.Basic.Types.Only (Internal.Data.Basic.Types.DbExp f a))
instance Internal.Data.Basic.Types.AggregatableBase (Internal.Data.Basic.Types.List (Internal.Data.Basic.Types.DbExp f a))
instance Internal.Data.Basic.Types.AggregatableBase (Internal.Data.Basic.Types.List (Internal.Data.Basic.Types.Var 'Internal.Data.Basic.Types.Folding a))
instance (Internal.Data.Basic.Types.MappableBase a, Internal.Data.Basic.Types.MappableBase b) => Internal.Data.Basic.Types.Mappable (a, b)
instance (Internal.Data.Basic.Types.MappableBase a, Internal.Data.Basic.Types.MappableBase b, Internal.Data.Basic.Types.MappableBase c) => Internal.Data.Basic.Types.Mappable (a, b, c)
instance (Internal.Data.Basic.Types.MappableBase a, Internal.Data.Basic.Types.MappableBase b, Internal.Data.Basic.Types.MappableBase c, Internal.Data.Basic.Types.MappableBase d) => Internal.Data.Basic.Types.Mappable (a, b, c, d)
instance (Internal.Data.Basic.Types.MappableBase a, Internal.Data.Basic.Types.MappableBase b, Internal.Data.Basic.Types.MappableBase c, Internal.Data.Basic.Types.MappableBase d, Internal.Data.Basic.Types.MappableBase e) => Internal.Data.Basic.Types.Mappable (a, b, c, d, e)
instance Internal.Data.Basic.Types.MappableBase a => Internal.Data.Basic.Types.Mappable a
instance Internal.Data.Basic.Types.MappableBase (Internal.Data.Basic.Types.DbExp k a)
instance Internal.Data.Basic.Types.Table t => Internal.Data.Basic.Types.MappableBase (Internal.Data.Basic.Types.Var 'Internal.Data.Basic.Types.Mapping t)
instance (Internal.Data.Basic.Types.GroupMappableBase a, Internal.Data.Basic.Types.GroupMappableBase b) => Internal.Data.Basic.Types.GroupMappable (a, b)
instance (Internal.Data.Basic.Types.GroupMappableBase a, Internal.Data.Basic.Types.GroupMappableBase b, Internal.Data.Basic.Types.GroupMappableBase c) => Internal.Data.Basic.Types.GroupMappable (a, b, c)
instance (Internal.Data.Basic.Types.GroupMappableBase a, Internal.Data.Basic.Types.GroupMappableBase b, Internal.Data.Basic.Types.GroupMappableBase c, Internal.Data.Basic.Types.GroupMappableBase d) => Internal.Data.Basic.Types.GroupMappable (a, b, c, d)
instance (Internal.Data.Basic.Types.GroupMappableBase a, Internal.Data.Basic.Types.GroupMappableBase b, Internal.Data.Basic.Types.GroupMappableBase c, Internal.Data.Basic.Types.GroupMappableBase d, Internal.Data.Basic.Types.GroupMappableBase e) => Internal.Data.Basic.Types.GroupMappable (a, b, c, d, e)
instance Internal.Data.Basic.Types.GroupMappableBase (m a) => Internal.Data.Basic.Types.GroupMappable (m a)
instance (Internal.Data.Basic.Types.Groupable a, Internal.Data.Basic.Types.Groupable b) => Internal.Data.Basic.Types.Groupable (a, b)
instance (Internal.Data.Basic.Types.Groupable a, Internal.Data.Basic.Types.Groupable b, Internal.Data.Basic.Types.Groupable c) => Internal.Data.Basic.Types.Groupable (a, b, c)
instance (Internal.Data.Basic.Types.Groupable a, Internal.Data.Basic.Types.Groupable b, Internal.Data.Basic.Types.Groupable c, Internal.Data.Basic.Types.Groupable d) => Internal.Data.Basic.Types.Groupable (a, b, c, d)
instance a ~ b => Internal.Data.Basic.Types.LiteralCollection (Internal.Data.Basic.Types.DbExp k a) b
instance forall k a (x :: k) b. (Internal.Data.Basic.Types.LiteralCollection a x, Internal.Data.Basic.Types.LiteralCollection b x) => Internal.Data.Basic.Types.LiteralCollection (a, b) x
instance forall k a (x :: k) b c. (Internal.Data.Basic.Types.LiteralCollection a x, Internal.Data.Basic.Types.LiteralCollection b x, Internal.Data.Basic.Types.LiteralCollection c x) => Internal.Data.Basic.Types.LiteralCollection (a, b, c) x
instance Internal.Data.Basic.Types.DbExp b x ~ a => Internal.Data.Basic.Types.LiteralCollection [a] x
instance GHC.Classes.Ord a => Internal.Data.Basic.Types.Sortable (Internal.Data.Basic.Types.DbExp k a)
instance Internal.Data.Basic.Types.Sortable a => Internal.Data.Basic.Types.Sortable (Data.Ord.Down a)
instance (Internal.Data.Basic.Types.Sortable a, Internal.Data.Basic.Types.Sortable b) => Internal.Data.Basic.Types.Sortable (a, b)
instance (Internal.Data.Basic.Types.Sortable a, Internal.Data.Basic.Types.Sortable b, Internal.Data.Basic.Types.Sortable c) => Internal.Data.Basic.Types.Sortable (a, b, c)
instance Internal.Data.Basic.Types.ValueAsDbExp' (Internal.Data.Basic.Types.IsDbExp a) a b => Internal.Data.Basic.Types.ValueAsDbExp a b
instance Internal.Data.Basic.Types.FoldCompositeIntoEntity '[] '[] a
instance (Internal.Data.Basic.Types.TableField a f, Internal.Data.Basic.Types.TableFieldType a f ~ t, Internal.Data.Basic.Types.FoldCompositeIntoEntity fs ts a) => Internal.Data.Basic.Types.FoldCompositeIntoEntity (f : fs) (t : ts) a
instance (fs ~ Internal.Data.Basic.Types.TableFields a, ts ~ Internal.Data.Basic.Types.TableFieldTypes a fs, Internal.Data.Basic.Types.FoldCompositeIntoEntity fs ts a, Internal.Composite.FieldParsers ts, Internal.Data.Basic.Types.Table a) => Database.PostgreSQL.Simple.FromField.FromField (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) a)
instance Internal.Data.Basic.Types.AllTypesSatisfy c table '[]
instance (Internal.Data.Basic.Types.TableField table x, c (Internal.Data.Basic.Types.TableFieldType table x) x, Internal.Data.Basic.Types.AllTypesSatisfy c table xs) => Internal.Data.Basic.Types.AllTypesSatisfy c table (x : xs)
instance (Internal.Data.Basic.TypeLevel.IsSubset (Internal.Data.Basic.Types.TableFields a) (Internal.Data.Basic.Types.TableFields a), Internal.Data.Basic.Types.AllTypesSatisfy Internal.Data.Basic.Types.JSONableField a (Internal.Data.Basic.Types.TableFields a)) => Data.Aeson.Types.ToJSON.ToJSON (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) a)
instance (Internal.Data.Basic.TypeLevel.IsSubset (Internal.Data.Basic.Types.SetFields fs a) (Internal.Data.Basic.Types.SetFields fs a), Internal.Data.Basic.Types.AllTypesSatisfy Internal.Data.Basic.Types.JSONableField a (Internal.Data.Basic.Types.SetFields fs a)) => Data.Aeson.Types.ToJSON.ToJSON (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.Fresh fs) a)
instance Internal.Data.Basic.Types.Table a => Internal.Data.Basic.Types.GetEntityFromValue '[] a
instance (Internal.Data.Basic.Types.GetEntityFromValue (Internal.Data.Basic.Types.SetFields miss a) a, Internal.Data.Basic.TypeLevel.SetEqual (Internal.Data.Basic.Types.MissingFieldsFromValue (Internal.Data.Basic.Types.SetFields miss a) a) miss) => Data.Aeson.Types.FromJSON.FromJSON (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.Fresh miss) a)
instance (Internal.Data.Basic.TypeLevel.AllSatisfy (Internal.Data.Basic.Types.OrdableField a) (Internal.Data.Basic.Types.SetFields (Internal.Data.Basic.Types.MissingFields entKind) a), GHC.Classes.Eq (Internal.Data.Basic.Types.Entity entKind a)) => GHC.Classes.Ord (Internal.Data.Basic.Types.Entity entKind a)
instance Internal.Data.Basic.TypeLevel.AllSatisfy (Internal.Data.Basic.Types.EqableField a) (Internal.Data.Basic.Types.SetFields (Internal.Data.Basic.Types.MissingFields entKind) a) => GHC.Classes.Eq (Internal.Data.Basic.Types.Entity entKind a)
instance (Internal.Data.Basic.Types.TableField table field, GHC.Classes.Ord (Internal.Data.Basic.Types.TableFieldType table field)) => Internal.Data.Basic.Types.OrdableField table field
instance (Internal.Data.Basic.Types.TableField table field, GHC.Classes.Eq (Internal.Data.Basic.Types.TableFieldType table field)) => Internal.Data.Basic.Types.EqableField table field
instance (Internal.Data.Basic.Types.ForeignKeyConstraint name, table ~ Internal.Data.Basic.Types.ForeignKeyFrom name) => Internal.Data.Basic.Types.ValidConstraint table ('Internal.Data.Basic.Types.ForeignKey name)
instance GHC.TypeLits.KnownSymbol (Internal.Data.Basic.Types.CapsName t s) => Internal.Data.Basic.Types.HasCapsFieldName t s
instance (Internal.Data.Basic.Types.UniqueConstraint name, table ~ Internal.Data.Basic.Types.UniqueTable name) => Internal.Data.Basic.Types.ValidConstraint table ('Internal.Data.Basic.Types.Unique name)
instance Internal.Data.Basic.Types.DbExp k b ~ a => Internal.Data.Basic.Types.ValueAsDbExp' 'GHC.Types.True a b
instance (a ~ b, Database.PostgreSQL.Simple.ToField.ToField a, Internal.Data.Basic.Types.KindOfDbExp a ~ 'Internal.Data.Basic.Types.LiteralExp) => Internal.Data.Basic.Types.ValueAsDbExp' 'GHC.Types.False a b
instance (Internal.Data.Basic.Types.GetEntityFromValue fs a, Data.Aeson.Types.FromJSON.FromJSON (Internal.Data.Basic.Types.TableFieldType a f), Internal.Data.Basic.Types.TableField a f) => Internal.Data.Basic.Types.GetEntityFromValue (f : fs) a
instance (k ~ 'Internal.Data.Basic.Types.LiteralExp, GHC.Num.Num a, Database.PostgreSQL.Simple.ToField.ToField a) => GHC.Num.Num (Internal.Data.Basic.Types.DbExp k a)
instance k ~ 'Internal.Data.Basic.Types.LiteralExp => Data.String.IsString (Internal.Data.Basic.Types.DbExp k Data.Text.Internal.Text)
instance Internal.Data.Basic.Types.TableSetVars ctx '[]
instance Internal.Data.Basic.Types.TableSetVars ctx '[a]
instance Internal.Data.Basic.Types.TableSetVars ctx '[a, b]
instance Internal.Data.Basic.Types.TableSetVars ctx '[a, b, c]
instance (GHC.TypeLits.KnownSymbol n, Data.Aeson.Types.ToJSON.ToJSON a) => Internal.Data.Basic.Types.JSONableField a n
instance Database.PostgreSQL.Simple.FromRow.FromRow a => Database.PostgreSQL.Simple.FromRow.FromRow (Internal.Data.Basic.Types.Entity l a)
instance Data.Aeson.Types.ToJSON.ToJSON (Internal.Data.Basic.Types.Entity entKind a) => GHC.Show.Show (Internal.Data.Basic.Types.Entity entKind a)
instance Database.PostgreSQL.Simple.ToField.ToField Internal.Data.Basic.Types.Key
instance Database.PostgreSQL.Simple.FromField.FromField Internal.Data.Basic.Types.Key
instance GHC.Num.Num Internal.Data.Basic.Types.Key
instance GHC.Show.Show Internal.Data.Basic.Types.Key
instance GHC.Read.Read Internal.Data.Basic.Types.Key
instance GHC.Classes.Ord Internal.Data.Basic.Types.Key
instance GHC.Classes.Eq Internal.Data.Basic.Types.Key
instance GHC.Show.Show (Internal.Data.Basic.Types.Var ctx a)
instance GHC.Read.Read (Internal.Data.Basic.Types.Var ctx a)
instance GHC.Classes.Ord (Internal.Data.Basic.Types.Var ctx a)
instance GHC.Classes.Eq (Internal.Data.Basic.Types.Var ctx a)
instance Data.Aeson.Types.FromJSON.FromJSON Internal.Data.Basic.Types.Key
instance Data.Aeson.Types.ToJSON.ToJSON Internal.Data.Basic.Types.Key

module Internal.Data.Basic.Lens
type PolyOptic fun inType outType inVal outVal = (inVal -> fun outVal) -> inType -> fun outType
type Getter' s a = PolyOptic (Const a) s s a a
fieldOpticVarExp :: forall name t anyCtx proxy. TableField t name => proxy name -> PolyOptic (Const (DbExp  'FieldExp (TableFieldType t name))) (Var anyCtx t) (Var anyCtx t) (DbExp  'FieldExp (TableFieldType t name)) (DbExp  'FieldExp (TableFieldType t name))
type GettableField entKind field = FieldIsGettable field (MissingFields entKind)
fieldOpticEntityGet :: forall name t entKind proxy. (TableField t name, GettableField entKind name) => proxy name -> PolyOptic (Const (TableFieldType t name)) (Entity entKind t) (Entity entKind t) (TableFieldType t name) (TableFieldType t name)
class SupportedModifyAccess isSet outVal where {
    type family ExistingValue isSet outVal :: *;
}
transformModifyFunction :: SupportedModifyAccess isSet outVal => (ExistingValue isSet outVal -> f outVal) -> outVal -> f outVal

-- | A field that's settable, but also potentially gettable (if it's
--   already set). If it is gettable then you can modify it, otherwise you
--   can just set it.
type ModifyableField table entKind field = SupportedModifyAccess (FieldIsGettableBool field (MissingFields entKind)) (TableFieldType table field)

-- | A synonym for ModifyableField. It still checks if the field is already
--   set.
type SettableField table entKind field = ModifyableField table entKind field
fieldOpticEntityModify :: forall name t entKind proxy. (TableField t name, ModifyableField t entKind name) => proxy name -> PolyOptic Identity (Entity entKind t) (Entity (WithFieldSet name entKind) t) (ExistingValue (FieldIsGettableBool name (MissingFields entKind)) (TableFieldType t name)) (TableFieldType t name)
fieldOpticUpdateVarSet :: forall name t val proxy. (ValueAsDbExp val (TableFieldType t name), TableField t name) => proxy name -> PolyOptic Identity (Var  'Updating t) (UpdateExp '[name] t) (DbExp  'FieldExp (TableFieldType t name)) val
fieldOpticUpdatedSet :: forall name t fields val proxy. (TableField t name, FieldIsNotSet name fields, ValueAsDbExp val (TableFieldType t name)) => proxy name -> PolyOptic Identity (UpdateExp fields t) (UpdateExp (name : fields) t) (DbExp  'FieldExp (TableFieldType t name)) val
class FieldOpticProxy t
fieldOpticProxy :: FieldOpticProxy t => t
fieldOptic :: forall name o. FieldOpticProxy (Proxy name -> o) => o
fieldOpticEntitySet :: forall name t missing. TableField t name => PolyOptic Identity (Entity missing t) (Entity (WithFieldSet name missing) t) () (TableFieldType t name)
instance (Internal.Data.Basic.Types.TableField t name, t5 ~ t, t4 ~ anyCtx, t3 ~ Data.Functor.Const.Const (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name)), t2 ~ (->) (Internal.Data.Basic.Types.Var anyCtx t), t1 ~ (->) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name) -> Data.Functor.Const.Const (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name)) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name))), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (t3 (Internal.Data.Basic.Types.Var t4 t5)))))
instance (Internal.Data.Basic.Types.TableField t name, t7 ~ Internal.Data.Basic.Types.Var anyCtx t, t6 ~ Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name), t5 ~ Data.Functor.Const.Const, t4 ~ t, t3 ~ anyCtx, t2 ~ (->), t1 ~ (->) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name) -> Data.Functor.Const.Const (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name)) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name))), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Internal.Data.Basic.Types.Var t3 t4) (t5 t6 t7))))
instance (Internal.Data.Basic.Types.TableField t name, t9 ~ Data.Functor.Const.Const (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name)) (Internal.Data.Basic.Types.Var anyCtx t), t8 ~ t, t7 ~ anyCtx, t6 ~ (->), t5 ~ Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name), t4 ~ Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name), t3 ~ Data.Functor.Const.Const, t2 ~ (->) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name)), t1 ~ (->), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (t3 t4 t5)) (t6 (Internal.Data.Basic.Types.Var t7 t8) t9)))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.TypeLevel.EqualOrError (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) 'GHC.Types.True (('GHC.TypeLits.Text "Field " 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType name) 'GHC.TypeLits.:<>: 'GHC.TypeLits.Text " is not set"), t6 ~ t, t5 ~ entKind, t4 ~ Internal.Data.Basic.Types.TableFieldType t name, t3 ~ Data.Functor.Const.Const, t2 ~ (->) (Internal.Data.Basic.Types.Entity entKind t), t1 ~ (->) (Internal.Data.Basic.Types.TableFieldType t name -> Data.Functor.Const.Const (Internal.Data.Basic.Types.TableFieldType t name) (Internal.Data.Basic.Types.TableFieldType t name)), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (t3 t4 (Internal.Data.Basic.Types.Entity t5 t6)))))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.TypeLevel.EqualOrError (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) 'GHC.Types.True (('GHC.TypeLits.Text "Field " 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType name) 'GHC.TypeLits.:<>: 'GHC.TypeLits.Text " is not set"), t9 ~ t, t8 ~ entKind, t7 ~ Data.Functor.Const.Const (Internal.Data.Basic.Types.TableFieldType t name), t6 ~ (->) (Internal.Data.Basic.Types.Entity entKind t), t5 ~ Internal.Data.Basic.Types.TableFieldType t name, t4 ~ Internal.Data.Basic.Types.TableFieldType t name, t3 ~ Data.Functor.Const.Const, t2 ~ (->) (Internal.Data.Basic.Types.TableFieldType t name), t1 ~ (->), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (t3 t4 t5)) (t6 (t7 (Internal.Data.Basic.Types.Entity t8 t9)))))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.TypeLevel.EqualOrError (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) 'GHC.Types.True (('GHC.TypeLits.Text "Field " 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType name) 'GHC.TypeLits.:<>: 'GHC.TypeLits.Text " is not set"), t7 ~ Internal.Data.Basic.Types.Entity entKind t, t6 ~ Internal.Data.Basic.Types.TableFieldType t name, t5 ~ Data.Functor.Const.Const, t4 ~ t, t3 ~ entKind, t2 ~ (->), t1 ~ (->) (Internal.Data.Basic.Types.TableFieldType t name -> Data.Functor.Const.Const (Internal.Data.Basic.Types.TableFieldType t name) (Internal.Data.Basic.Types.TableFieldType t name)), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Internal.Data.Basic.Types.Entity t3 t4) (t5 t6 t7))))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.TypeLevel.EqualOrError (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) 'GHC.Types.True (('GHC.TypeLits.Text "Field " 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType name) 'GHC.TypeLits.:<>: 'GHC.TypeLits.Text " is not set"), t9 ~ Data.Functor.Const.Const (Internal.Data.Basic.Types.TableFieldType t name) (Internal.Data.Basic.Types.Entity entKind t), t8 ~ t, t7 ~ entKind, t6 ~ (->), t5 ~ Internal.Data.Basic.Types.TableFieldType t name, t4 ~ Internal.Data.Basic.Types.TableFieldType t name, t3 ~ Data.Functor.Const.Const, t2 ~ (->) (Internal.Data.Basic.Types.TableFieldType t name), t1 ~ (->), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (t3 t4 t5)) (t6 (Internal.Data.Basic.Types.Entity t7 t8) t9)))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.Lens.SupportedModifyAccess (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name), t4 ~ t, t3 ~ Internal.Data.Basic.Types.WithFieldSet name entKind, t2 ~ (->) (Internal.Data.Basic.Types.Entity entKind t), t1 ~ (->) (Internal.Data.Basic.Lens.ExistingValue (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name) -> Data.Functor.Identity.Identity (Internal.Data.Basic.Types.TableFieldType t name)), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Data.Functor.Identity.Identity (Internal.Data.Basic.Types.Entity t3 t4)))))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.Lens.SupportedModifyAccess (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name), t5 ~ Internal.Data.Basic.Types.Entity (Internal.Data.Basic.Types.WithFieldSet name entKind) t, t4 ~ t, t3 ~ entKind, t2 ~ (->), t1 ~ (->) (Internal.Data.Basic.Lens.ExistingValue (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name) -> Data.Functor.Identity.Identity (Internal.Data.Basic.Types.TableFieldType t name)), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Internal.Data.Basic.Types.Entity t3 t4) (Data.Functor.Identity.Identity t5))))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.Lens.SupportedModifyAccess (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name), t7 ~ t, t6 ~ Internal.Data.Basic.Types.WithFieldSet name entKind, t5 ~ Data.Functor.Identity.Identity, t4 ~ (->) (Internal.Data.Basic.Types.Entity entKind t), t3 ~ Internal.Data.Basic.Types.TableFieldType t name, t2 ~ (->) (Internal.Data.Basic.Lens.ExistingValue (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name)), t1 ~ (->), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Data.Functor.Identity.Identity t3)) (t4 (t5 (Internal.Data.Basic.Types.Entity t6 t7)))))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.Lens.SupportedModifyAccess (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name), t7 ~ Data.Functor.Identity.Identity (Internal.Data.Basic.Types.Entity (Internal.Data.Basic.Types.WithFieldSet name entKind) t), t6 ~ t, t5 ~ entKind, t4 ~ (->), t3 ~ Internal.Data.Basic.Types.TableFieldType t name, t2 ~ (->) (Internal.Data.Basic.Lens.ExistingValue (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name (Internal.Data.Basic.Types.MissingFieldsNames (Internal.Data.Basic.Types.MissingFields entKind)))) (Internal.Data.Basic.Types.TableFieldType t name)), t1 ~ (->), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Data.Functor.Identity.Identity t3)) (t4 (Internal.Data.Basic.Types.Entity t5 t6) t7)))
instance (Internal.Data.Basic.Types.ValueAsDbExp val (Internal.Data.Basic.Types.TableFieldType t name), Internal.Data.Basic.Types.TableField t name, t7 ~ t, t6 ~ '[name], t5 ~ Data.Functor.Identity.Identity, t4 ~ t, t3 ~ 'Internal.Data.Basic.Types.Updating, t2 ~ (->), t1 ~ (->) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name) -> Data.Functor.Identity.Identity val), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Internal.Data.Basic.Types.Var t3 t4) (t5 (Internal.Data.Basic.Types.UpdateExp t6 t7)))))
instance (Internal.Data.Basic.Types.ValueAsDbExp val (Internal.Data.Basic.Types.TableFieldType t name), Internal.Data.Basic.Types.TableField t name, t5 ~ Internal.Data.Basic.Types.UpdateExp '[name] t, t4 ~ t, t3 ~ 'Internal.Data.Basic.Types.Updating, t2 ~ (->), t1 ~ (->) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name) -> Data.Functor.Identity.Identity val), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Internal.Data.Basic.Types.Var t3 t4) (Data.Functor.Identity.Identity t5))))
instance (Internal.Data.Basic.Types.ValueAsDbExp val (Internal.Data.Basic.Types.TableFieldType t name), Internal.Data.Basic.Types.TableField t name, t7 ~ Data.Functor.Identity.Identity (Internal.Data.Basic.Types.UpdateExp '[name] t), t6 ~ t, t5 ~ 'Internal.Data.Basic.Types.Updating, t4 ~ (->), t3 ~ val, t2 ~ (->) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name)), t1 ~ (->), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Data.Functor.Identity.Identity t3)) (t4 (Internal.Data.Basic.Types.Var t5 t6) t7)))
instance (Internal.Data.Basic.Types.TableField t name, Internal.Data.Basic.TypeLevel.EqualOrError (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem name fields)) 'GHC.Types.True (('GHC.TypeLits.Text "Cannot update the field " 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType name) 'GHC.TypeLits.:<>: 'GHC.TypeLits.Text " because it's already updated in this expression"), Internal.Data.Basic.Types.ValueAsDbExp val (Internal.Data.Basic.Types.TableFieldType t name), t5 ~ Data.Functor.Identity.Identity (Internal.Data.Basic.Types.UpdateExp (name : fields) t), t4 ~ t, t3 ~ fields, t2 ~ (->), t1 ~ (->) (Internal.Data.Basic.Types.DbExp 'Internal.Data.Basic.Types.FieldExp (Internal.Data.Basic.Types.TableFieldType t name) -> Data.Functor.Identity.Identity val), t0 ~ (->) (proxy name)) => Internal.Data.Basic.Lens.FieldOpticProxy (t0 (t1 (t2 (Internal.Data.Basic.Types.UpdateExp t3 t4) t5)))
instance Internal.Data.Basic.Lens.SupportedModifyAccess 'GHC.Types.True outVal
instance Internal.Data.Basic.Lens.SupportedModifyAccess 'GHC.Types.False outVal

module Internal.Data.Basic.Compiler
expToSql :: DbExp k a -> SqlValueExp
varToSql :: Var k a -> SqlValueExp
someDbExpToSqlExp :: SomeDbExp -> SqlValueExp
literalCollectionToSql :: LiteralCollection collection a => collection -> [SqlValueExp]
boolExpToSql :: ConditionExp -> Condition
conditionToSql :: forall tables. TableSetVars  'Filtering tables => (Variables  'Filtering tables -> ConditionExp) -> Condition
uniqueNames :: [QualifiedTable] -> [QualifiedTable]
compileTable :: forall name proxy. KnownSymbol name => proxy (name :: Symbol) -> SqlExp
updatedExpToSql :: forall fields table. UpdateExp fields table -> ([Text], [SqlValueExp])
updateToSql :: forall table fields. (Var  'Updating table -> UpdateExp fields table) -> ([Text], [SqlValueExp])
orderingToSql :: forall tables ord. (Sortable ord, TableSetVars  'Sorting tables) => (Variables  'Sorting tables -> ord) -> [(SqlValueExp, SortDirection)]
mappingToSql :: forall tables map. (Mappable map, TableSetVars  'Mapping tables) => (Variables  'Mapping tables -> map) -> [SqlValueExp]
mapToSql :: Mappable map => map -> [SqlValueExp]
groupMapToSql :: GroupMappable map => map -> [SqlValueExp]
grouppingToSql :: forall tables group. (Groupable group, TableSetVars  'Grouping tables) => (Variables  'Grouping tables -> group) -> [SqlValueExp]
groupStatementToSql :: forall tables group. GroupStatement group tables -> SqlExp
foldingToSql :: forall tables aggr. (Aggregatable aggr, TableSetVars  'Folding tables) => (Variables  'Folding tables -> aggr) -> [SqlValueExp]
aggregateStatementToSql :: AggregateStatement aggr  'AM -> SqlExp
compileToSql :: DbStatement f ts -> SqlExp

module Internal.Data.Basic.Compare
class ComparableInDbExp (a :: *) (b :: *)
compareInDbExp :: ComparableInDbExp a b => Comparison -> a -> b -> ConditionExp
(>.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 >.
(==.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 ==.
(/=.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 /=.
(<.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 <.
(<=.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 <=.
(>=.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 >=.
(&&.) :: ConditionExp -> ConditionExp -> ConditionExp
infixr 3 &&.
(||.) :: ConditionExp -> ConditionExp -> ConditionExp
infixr 2 ||.
instance (Internal.Data.Basic.Types.ValueAsDbExp b a, GHC.Classes.Ord a) => Internal.Data.Basic.Compare.ComparableInDbExp (Internal.Data.Basic.Types.DbExp k a) b
instance (Internal.Data.Basic.Types.ValueAsDbExp a b, GHC.Classes.Ord b) => Internal.Data.Basic.Compare.ComparableInDbExp a (Internal.Data.Basic.Types.DbExp k b)

module Internal.Control.Effects.Basic
newtype SqlRequest a
SqlRequest :: SqlExp -> SqlRequest a
[$sel:getSqlRequest:SqlRequest] :: SqlRequest a -> SqlExp
data Basic
runSql :: MonadEffect Basic m => forall a. FromRow a => SqlRequest a -> m [a]
executeSql :: MonadEffect Basic m => SqlExp -> m ()
data BasicException
BasicFormatError :: FormatError -> BasicException
BasicQueryError :: QueryError -> BasicException
BasicResultError :: ResultError -> BasicException
BasicSqlError :: SqlError -> BasicException

-- | Handles SQL by querying a PostgreSQL database. Leaves logs unhandled.
handleBasicPsqlWithLogging :: forall m a. (MonadEffects '[Logging, Signal BasicException Query] m, MonadIO m) => Connection -> RuntimeImplemented Basic m a -> m a
throwBasicToIO :: forall m a. MonadIO m => ExceptT BasicException m a -> m a
logOnlyErrors :: MonadEffect Logging m => RuntimeImplemented Logging m a -> m a

-- | Handles SQL by querying a PostgreSQL database. Writes logs to console.
handleBasicPsql :: MonadIO m => Connection -> RuntimeImplemented Basic (RuntimeImplemented Logging (ExceptT BasicException m)) a -> m a
class (FromRow (AllTables ts)) => AllHaveFromRowInstance ts
compositeToTuple :: AllHaveFromRowInstance ts => proxy ts -> AllTables ts -> DbResult ts
runDbStatement :: forall ts m f. (AllHaveFromRowInstance ts, MonadEffect Basic m) => DbStatement f ts -> m [DbResult ts]
executeDbStatement :: MonadEffect Basic m => DbStatement f ts -> m ()
runAggregateStatement :: forall aggr m. (MonadEffect Basic m, FromRow (AggregationResult aggr)) => AggregateStatement aggr  'AM -> m (AggregationResult aggr)
class NoOnly a
noOnly :: NoOnly a => a -> WithoutOnly a
runMapStatement :: forall res m f. (MonadEffect Basic m, FromRow res, NoOnly res) => DbStatement f '[res] -> m [WithoutOnly res]
instance GHC.Show.Show Internal.Control.Effects.Basic.BasicException
instance GHC.Classes.Eq Internal.Control.Effects.Basic.BasicException
instance forall k (a :: k). GHC.Show.Show (Internal.Control.Effects.Basic.SqlRequest a)
instance Internal.Control.Effects.Basic.NoOnly (Database.PostgreSQL.Simple.Types.Only a)
instance Internal.Control.Effects.Basic.WithoutOnly a ~ a => Internal.Control.Effects.Basic.NoOnly a
instance Database.PostgreSQL.Simple.FromRow.FromRow a => Internal.Control.Effects.Basic.AllHaveFromRowInstance '[a]
instance (Database.PostgreSQL.Simple.FromRow.FromRow a, Database.PostgreSQL.Simple.FromRow.FromRow b) => Internal.Control.Effects.Basic.AllHaveFromRowInstance '[a, b]
instance (Database.PostgreSQL.Simple.FromRow.FromRow a, Database.PostgreSQL.Simple.FromRow.FromRow b, Database.PostgreSQL.Simple.FromRow.FromRow c) => Internal.Control.Effects.Basic.AllHaveFromRowInstance '[a, b, c]
instance Control.Effects.Effect Internal.Control.Effects.Basic.Basic

module Internal.Data.Basic.Common
class LiftedStatement fs t res
liftDbExp :: LiftedStatement fs t res => DbStatement fs t -> res
djoin :: LiftedStatement  'Unfiltered (tables1 ++ tables2) res => DbStatement  'Unfiltered tables1 -> DbStatement  'Unfiltered tables2 -> res
dfilter :: (LiftedStatement  'Filtered tables res, TableSetVars  'Filtering tables, Selection f) => (Variables  'Filtering tables -> ConditionExp) -> DbStatement f tables -> res
ddelete :: (LiftedStatement  'Deleted '[table] res, Selection f, Table table) => DbStatement f '[table] -> res
type AllRows table res = (Table table, LiftedStatement  'Unfiltered '[table] res)
allRows :: forall tableName table res. (TableName table ~ tableName, AllRows table res) => res
allRowsProxy :: forall table res proxy. (Table table, LiftedStatement  'Unfiltered '[table] res) => proxy table -> res
rawQuery :: forall a r m. (MonadEffect Basic m, FromRow a, ToRow r) => Text -> r -> m [Entity ( 'FromDb  'Live) a]
insert :: (CanInsert entKind table, MonadEffect Basic m, FromRow table) => Entity entKind table -> m (Entity ( 'FromDb  'Live) table)
dupdate :: (MonadEffect Basic m, FromRow table, Selection f) => (Var  'Updating table -> UpdateExp fields table) -> DbStatement f '[table] -> m [Entity ( 'FromDb  'Live) table]
dsortOn :: (LiftedStatement  'Sorted tables res, TableSetVars  'Sorting tables, Sortable ord, Selection f) => (Variables  'Sorting tables -> ord) -> DbStatement f tables -> res
dtake :: (LiftedStatement  'Limited tables res, CanTake f) => Int -> DbStatement f tables -> res
dgroupOn :: (Groupable group, TableSetVars  'Grouping tables, Selection f) => (Variables  'Grouping tables -> group) -> DbStatement f tables -> GroupStatement group tables
dmapAll :: (Mappable map, CanMap f, TableSetVars  'Mapping tables) => (Variables  'Mapping tables -> map) -> DbStatement f tables -> DbStatement  'Mapped '[MapResult map]
dgroupMap :: (GroupMappable map, InterpretAsGroupMap map ~  'True) => ((AsAggregate group, DbStatement  'Grouped tables) -> map) -> GroupStatement group tables -> DbStatement  'Folded '[GroupMapResult map]
class Dmap' t
dmap' :: Dmap' t => t
class LiftedMapStatement fs t res
liftMapStatement :: LiftedMapStatement fs t res => DbStatement fs '[t] -> res
dmap :: forall f res a b m (ts :: [*]) t. (Dmap' ((a -> b) -> m ts -> DbStatement f '[t]), LiftedMapStatement f t res) => (a -> b) -> m ts -> res
class interpretAsGroupMap ~ InterpretAsGroupMap res => LiftedAggregation (interpretAsGroupMap :: Bool) aggr res
liftAggregation :: LiftedAggregation interpretAsGroupMap aggr res => AggregateStatement aggr  'AM -> res
dfoldMap :: forall tables aggr f res. (Aggregatable aggr, CanAggregate f, TableSetVars  'Folding tables, LiftedAggregation (InterpretAsGroupMap res) aggr res) => (Variables  'Folding tables -> aggr) -> DbStatement f tables -> res
dfoldMapInner :: (AsAggregate group ~ GroupMappableThing t  'AM, LiftedMapStatement  'Folded (ListToSimpleTuple (TupleToList t ++ TupleToList (AggregationResult aggr))) res, Aggregatable aggr, TableSetVars  'Folding tables) => (Variables  'Folding tables -> aggr) -> GroupStatement group tables -> res
delem :: (LiteralCollection collection a) => DbExp k a -> collection -> ConditionExp
disNothing :: DbExp  'FieldExp (Maybe a) -> ConditionExp
disJust :: DbExp  'FieldExp (Maybe a) -> ConditionExp
dtrue :: ConditionExp
dfalse :: ConditionExp
like :: DbExp  'FieldExp Text -> Text -> ConditionExp
ilike :: DbExp  'FieldExp Text -> Text -> ConditionExp
executeQuery :: (ToRow r, MonadEffect Basic m) => Text -> r -> m ()
applySchema :: MonadEffect Basic m => Schema -> m ()
instance (Internal.Data.Basic.Types.GroupMappableThing (Internal.Data.Basic.Types.AggregationResult aggr) 'Internal.Data.Basic.Types.AM ~ aggStat, Internal.Data.Basic.Types.Aggregatable aggr, Internal.Data.Basic.Types.InterpretAsGroupMap aggStat ~ 'GHC.Types.True) => Internal.Data.Basic.Common.LiftedAggregation 'GHC.Types.True aggr aggStat
instance (Internal.Data.Basic.Types.GroupMappableThing (Internal.Data.Basic.Types.AggregationResult aggr) ~ aggStat, m ~ 'Internal.Data.Basic.Types.AM, Internal.Data.Basic.Types.Aggregatable aggr, Internal.Data.Basic.Types.InterpretAsGroupMap (aggStat m) ~ i) => Internal.Data.Basic.Common.LiftedAggregation i aggr (aggStat m)
instance (res ~ Internal.Data.Basic.Types.AggregationResult aggr, Control.Effects.MonadEffect Internal.Control.Effects.Basic.Basic m, Database.PostgreSQL.Simple.FromRow.FromRow res, Internal.Data.Basic.Types.InterpretAsGroupMap (m res) ~ i) => Internal.Data.Basic.Common.LiftedAggregation i aggr (m res)
instance (Internal.Data.Basic.Types.DbStatement fs ~ dbs, '[ts1] ~ ts2) => Internal.Data.Basic.Common.LiftedMapStatement fs ts1 (dbs ts2)
instance (res ~ [Internal.Control.Effects.Basic.WithoutOnly ts], Control.Effects.MonadEffect Internal.Control.Effects.Basic.Basic m, Database.PostgreSQL.Simple.FromRow.FromRow ts, Internal.Control.Effects.Basic.NoOnly ts) => Internal.Data.Basic.Common.LiftedMapStatement fs ts (m res)
instance (Internal.Data.Basic.Types.Mappable map, Internal.Data.Basic.Types.CanMap f, Internal.Data.Basic.Types.TableSetVars 'Internal.Data.Basic.Types.Mapping tables, t3 ~ '[Internal.Data.Basic.Types.MapResult map], t2 ~ Internal.Data.Basic.Types.DbStatement, t1 ~ (->) (Internal.Data.Basic.Types.DbStatement f tables), t0 ~ (->) (Internal.Data.Basic.TypeLevel.ListToTuple (Internal.Data.Basic.Types.Var 'Internal.Data.Basic.Types.Mapping) tables -> map)) => Internal.Data.Basic.Common.Dmap' (t0 (t1 (t2 'Internal.Data.Basic.Types.Mapped t3)))
instance (Internal.Data.Basic.Types.Mappable map, Internal.Data.Basic.Types.CanMap f, Internal.Data.Basic.Types.TableSetVars 'Internal.Data.Basic.Types.Mapping tables, t4 ~ Internal.Data.Basic.Types.DbStatement 'Internal.Data.Basic.Types.Mapped '[Internal.Data.Basic.Types.MapResult map], t3 ~ tables, t2 ~ f, t1 ~ (->), t0 ~ (->) (Internal.Data.Basic.TypeLevel.ListToTuple (Internal.Data.Basic.Types.Var 'Internal.Data.Basic.Types.Mapping) tables -> map)) => Internal.Data.Basic.Common.Dmap' (t0 (t1 (Internal.Data.Basic.Types.DbStatement t2 t3) t4))
instance (Internal.Data.Basic.Types.GroupMappable map, Internal.Data.Basic.Types.InterpretAsGroupMap map ~ 'GHC.Types.True, t3 ~ '[Internal.Data.Basic.Types.GroupMapResult map], t2 ~ Internal.Data.Basic.Types.DbStatement, t1 ~ (->) (Internal.Data.Basic.Types.GroupStatement group tables), t0 ~ (->) ((Internal.Data.Basic.Types.AsAggregate group, Internal.Data.Basic.Types.DbStatement 'Internal.Data.Basic.Types.Grouped tables) -> map)) => Internal.Data.Basic.Common.Dmap' (t0 (t1 (t2 'Internal.Data.Basic.Types.Folded t3)))
instance (Internal.Data.Basic.Types.GroupMappable map, Internal.Data.Basic.Types.InterpretAsGroupMap map ~ 'GHC.Types.True, t4 ~ Internal.Data.Basic.Types.DbStatement 'Internal.Data.Basic.Types.Folded '[Internal.Data.Basic.Types.GroupMapResult map], t3 ~ tables, t2 ~ group, t1 ~ (->), t0 ~ (->) ((Internal.Data.Basic.Types.AsAggregate group, Internal.Data.Basic.Types.DbStatement 'Internal.Data.Basic.Types.Grouped tables) -> map)) => Internal.Data.Basic.Common.Dmap' (t0 (t1 (Internal.Data.Basic.Types.GroupStatement t2 t3) t4))
instance (Internal.Data.Basic.Types.DbStatement fs ~ dbs, ts1 ~ ts2) => Internal.Data.Basic.Common.LiftedStatement fs ts1 (dbs ts2)
instance (res ~ [Internal.Data.Basic.Types.DbResult ts], Internal.Control.Effects.Basic.AllHaveFromRowInstance ts, Control.Effects.MonadEffect Internal.Control.Effects.Basic.Basic m) => Internal.Data.Basic.Common.LiftedStatement fs ts (m res)

module Internal.Data.Basic.Virtual
fieldMatch :: forall (toField :: Symbol) (fromField :: Symbol) toTable fromTable c. (TableField toTable toField, TableField fromTable fromField, TableFieldType toTable toField ~ TableFieldType fromTable fromField, Ord (TableFieldType toTable toField), ToField (TableFieldType toTable toField)) => Entity ( 'FromDb c) toTable -> Var  'Filtering fromTable -> ConditionExp
class (Table fromTable, Table toTable, AllSatisfy (TableField fromTable) fromFields, AllSatisfy (TableField toTable) toFields, SameTypes toTable toFields fromTable fromFields, AllTypesSatisfy (TypeSatisfies Ord) fromTable fromFields, AllTypesSatisfy (TypeSatisfies ToField) fromTable fromFields) => AllFieldsMatch (toFields :: [Symbol]) (fromFields :: [Symbol]) toTable fromTable
allFieldsMatch :: AllFieldsMatch toFields fromFields toTable fromTable => Entity ( 'FromDb c) toTable -> Var  'Filtering fromTable -> ConditionExp
virtualTableDbExpLens :: forall foreignKeyName c. (ForeignKeyConstraint foreignKeyName, AllFieldsMatch (ForeignKeyToFields foreignKeyName) (ForeignKeyFromFields foreignKeyName) (ForeignKeyTo foreignKeyName) (ForeignKeyFrom foreignKeyName)) => Getter' (Entity ( 'FromDb c) (ForeignKeyTo foreignKeyName)) (DbStatement  'Filtered '[ForeignKeyFrom foreignKeyName])
type VirtualTable foreignKeyName res = (ForeignKeyConstraint foreignKeyName, AllFieldsMatch (ForeignKeyToFields foreignKeyName) (ForeignKeyFromFields foreignKeyName) (ForeignKeyTo foreignKeyName) (ForeignKeyFrom foreignKeyName), LiftedStatement  'Filtered '[(ForeignKeyFrom foreignKeyName)] res)
virtualTableLens :: forall foreignKeyName c res. VirtualTable foreignKeyName res => Getter' (Entity ( 'FromDb c) (ForeignKeyTo foreignKeyName)) (res)
virtualTableLensProxy :: forall foreignKeyName res c proxy. VirtualTable foreignKeyName res => proxy foreignKeyName -> Getter' (Entity ( 'FromDb c) (ForeignKeyTo foreignKeyName)) (res)
instance (Internal.Data.Basic.Types.Table fromTable, Internal.Data.Basic.Types.Table toTable, Internal.Data.Basic.Types.TableField fromTable fromField, Internal.Data.Basic.Types.TableField toTable toField, Internal.Data.Basic.Types.TableFieldType fromTable fromField ~ Internal.Data.Basic.Types.TableFieldType toTable toField, GHC.Classes.Ord (Internal.Data.Basic.Types.TableFieldType toTable toField), Database.PostgreSQL.Simple.ToField.ToField (Internal.Data.Basic.Types.TableFieldType fromTable fromField)) => Internal.Data.Basic.Virtual.AllFieldsMatch '[toField] '[fromField] toTable fromTable
instance (Internal.Data.Basic.Types.Table fromTable, Internal.Data.Basic.Types.Table toTable, Internal.Data.Basic.Types.TableField fromTable fromField, Internal.Data.Basic.Types.TableField toTable toField, Internal.Data.Basic.Types.TableFieldType fromTable fromField ~ Internal.Data.Basic.Types.TableFieldType toTable toField, GHC.Classes.Ord (Internal.Data.Basic.Types.TableFieldType toTable toField), Database.PostgreSQL.Simple.ToField.ToField (Internal.Data.Basic.Types.TableFieldType fromTable fromField), Internal.Data.Basic.Virtual.AllFieldsMatch toFields fromFields toTable fromTable) => Internal.Data.Basic.Virtual.AllFieldsMatch (toField : toFields) (fromField : fromFields) toTable fromTable

module Internal.Data.Basic.Replace
class PrimaryKeyMatch (fields :: [Symbol]) table
primaryKeyMatch :: PrimaryKeyMatch fields table => Entity ( 'FromDb c) table -> Var  'Filtering table -> ConditionExp
class SetAllFields fields table
setAllFields :: SetAllFields fields table => Entity ( 'FromDb c) table -> Var  'Updating table -> UpdateExp fields table
save :: forall table pk fields c m. (Table table, 'Just pk ~ TablePrimaryKey table, fields ~ UniqueFields pk, PrimaryKeyMatch fields table, SetAllFields (TableFields table) table, MonadEffect Basic m) => Entity ( 'FromDb c) table -> m (Entity ( 'FromDb  'Live) table)
instance Internal.Data.Basic.Replace.SetAllFields '[] table
instance (Internal.Data.Basic.Replace.SetAllFields fields table, Internal.Data.Basic.TypeLevel.CheckWithError (Internal.Data.Basic.TypeLevel.Not (Internal.Data.Basic.TypeLevel.Elem field fields)) (('GHC.TypeLits.Text "Cannot update the field " 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType field) 'GHC.TypeLits.:<>: 'GHC.TypeLits.Text " because it's already updated in this expression"), Internal.Data.Basic.Types.TableField table field, Database.PostgreSQL.Simple.ToField.ToField (Internal.Data.Basic.Types.TableFieldType table field), Internal.Data.Basic.Types.KindOfDbExp (Internal.Data.Basic.Types.TableFieldType table field) ~ 'Internal.Data.Basic.Types.LiteralExp) => Internal.Data.Basic.Replace.SetAllFields (field : fields) table
instance (GHC.Classes.Ord (Internal.Data.Basic.Types.TableFieldType table field), Internal.Data.Basic.Types.TableField table field, Database.PostgreSQL.Simple.ToField.ToField (Internal.Data.Basic.Types.TableFieldType table field), Internal.Data.Basic.Types.KindOfDbExp (Internal.Data.Basic.Types.TableFieldType table field) ~ 'Internal.Data.Basic.Types.LiteralExp) => Internal.Data.Basic.Replace.PrimaryKeyMatch '[field] table
instance (GHC.Classes.Ord (Internal.Data.Basic.Types.TableFieldType table field), Internal.Data.Basic.Types.TableField table field, Database.PostgreSQL.Simple.ToField.ToField (Internal.Data.Basic.Types.TableFieldType table field), fields ~ (f : fs), Internal.Data.Basic.Replace.PrimaryKeyMatch fields table, Internal.Data.Basic.Types.KindOfDbExp (Internal.Data.Basic.Types.TableFieldType table field) ~ 'Internal.Data.Basic.Types.LiteralExp) => Internal.Data.Basic.Replace.PrimaryKeyMatch (field : f : fs) table

module Internal.Data.Basic.Foreign
class ForeignKeyConstraint fk => ForeignKeyFieldsMatch (fk :: Symbol) (fromFields :: [Symbol]) (toFields :: [Symbol])
foreignKeyFieldsMatch :: ForeignKeyFieldsMatch fk fromFields toFields => Entity ( 'FromDb c) (ForeignKeyFrom fk) -> Var  'Filtering (ForeignKeyTo fk) -> ConditionExp
foreignKeyFieldsSet :: ForeignKeyFieldsMatch fk fromFields toFields => Entity entKind (ForeignKeyFrom fk) -> Entity ( 'FromDb c) (ForeignKeyTo fk) -> Entity (WithFieldsSet fromFields entKind) (ForeignKeyFrom fk)
type ForeignKeyLensGet fk m = (ForeignKeyConstraint fk, MonadEffect Basic m, Table (ForeignKeyFrom fk), Table (ForeignKeyTo fk), ForeignKeyFieldsMatch fk (ForeignKeyFromFields fk) (ForeignKeyToFields fk))
foreignKeyLensGet :: forall fk m proxy. ForeignKeyLensGet fk m => proxy fk -> Getter' (Entity ( 'FromDb  'Live) (ForeignKeyFrom fk)) (m (Entity ( 'FromDb  'Live) (ForeignKeyTo fk)))
type ForeignKeyLensSet fk = (ForeignKeyConstraint fk, ForeignKeyFieldsMatch fk (ForeignKeyFromFields fk) (ForeignKeyToFields fk))
foreignKeyLensSet :: forall fk entKind c proxy. ForeignKeyLensSet fk => proxy fk -> PolyOptic Identity (Entity entKind (ForeignKeyFrom fk)) (Entity (WithFieldsSet (ForeignKeyFromFields fk) entKind) (ForeignKeyFrom fk)) () (Entity ( 'FromDb c) (ForeignKeyTo fk))
class ForeignKeyLensProxy t
foreignKeyLensProxy :: ForeignKeyLensProxy t => t
foreignKeyLens :: forall name o. ForeignKeyLensProxy (Proxy name -> o) => o
instance ((Internal.Data.Basic.Types.ForeignKeyConstraint fk, Control.Effects.MonadEffect Internal.Control.Effects.Basic.Basic m, Internal.Data.Basic.Types.Table (Internal.Data.Basic.Types.ForeignKeyFrom fk), Internal.Data.Basic.Types.Table (Internal.Data.Basic.Types.ForeignKeyTo fk), Internal.Data.Basic.Foreign.ForeignKeyFieldsMatch fk (Internal.Data.Basic.Types.ForeignKeyFromFields fk) (Internal.Data.Basic.Types.ForeignKeyToFields fk)), t5 ~ Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyFrom fk), t4 ~ m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk)), t3 ~ Data.Functor.Const.Const, t2 ~ (->) (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyFrom fk)), t1 ~ (->) (m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk)) -> Data.Functor.Const.Const (m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk))) (m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk)))), t0 ~ (->) (proxy fk)) => Internal.Data.Basic.Foreign.ForeignKeyLensProxy (t0 (t1 (t2 (t3 t4 t5))))
instance ((Internal.Data.Basic.Types.ForeignKeyConstraint fk, Control.Effects.MonadEffect Internal.Control.Effects.Basic.Basic m, Internal.Data.Basic.Types.Table (Internal.Data.Basic.Types.ForeignKeyFrom fk), Internal.Data.Basic.Types.Table (Internal.Data.Basic.Types.ForeignKeyTo fk), Internal.Data.Basic.Foreign.ForeignKeyFieldsMatch fk (Internal.Data.Basic.Types.ForeignKeyFromFields fk) (Internal.Data.Basic.Types.ForeignKeyToFields fk)), t6 ~ (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyFrom fk) -> Data.Functor.Const.Const (m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk))) (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyFrom fk))), t5 ~ m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk)), t4 ~ m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk)), t3 ~ Data.Functor.Const.Const, t2 ~ (->) (m (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb 'Internal.Data.Basic.Types.Live) (Internal.Data.Basic.Types.ForeignKeyTo fk))), t1 ~ (->), t0 ~ (->) (proxy fk)) => Internal.Data.Basic.Foreign.ForeignKeyLensProxy (t0 (t1 (t2 (t3 t4 t5)) t6))
instance ((Internal.Data.Basic.Types.ForeignKeyConstraint fk, Internal.Data.Basic.Foreign.ForeignKeyFieldsMatch fk (Internal.Data.Basic.Types.ForeignKeyFromFields fk) (Internal.Data.Basic.Types.ForeignKeyToFields fk)), t3 ~ Internal.Data.Basic.Types.Entity (Internal.Data.Basic.Types.WithFieldsSet (Internal.Data.Basic.Types.ForeignKeyFromFields fk) entKind) (Internal.Data.Basic.Types.ForeignKeyFrom fk), t2 ~ (->) (Internal.Data.Basic.Types.Entity entKind (Internal.Data.Basic.Types.ForeignKeyFrom fk)), t1 ~ (->) (() -> Data.Functor.Identity.Identity (Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb c) (Internal.Data.Basic.Types.ForeignKeyTo fk))), t0 ~ (->) (proxy fk)) => Internal.Data.Basic.Foreign.ForeignKeyLensProxy (t0 (t1 (t2 (Data.Functor.Identity.Identity t3))))
instance ((Internal.Data.Basic.Types.ForeignKeyConstraint fk, Internal.Data.Basic.Foreign.ForeignKeyFieldsMatch fk (Internal.Data.Basic.Types.ForeignKeyFromFields fk) (Internal.Data.Basic.Types.ForeignKeyToFields fk)), t4 ~ (Internal.Data.Basic.Types.Entity entKind (Internal.Data.Basic.Types.ForeignKeyFrom fk) -> Data.Functor.Identity.Identity (Internal.Data.Basic.Types.Entity (Internal.Data.Basic.Types.WithFieldsSet (Internal.Data.Basic.Types.ForeignKeyFromFields fk) entKind) (Internal.Data.Basic.Types.ForeignKeyFrom fk))), t3 ~ Internal.Data.Basic.Types.Entity ('Internal.Data.Basic.Types.FromDb c) (Internal.Data.Basic.Types.ForeignKeyTo fk), t2 ~ (->) (), t1 ~ (->), t0 ~ (->) (proxy fk)) => Internal.Data.Basic.Foreign.ForeignKeyLensProxy (t0 (t1 (t2 (Data.Functor.Identity.Identity t3)) t4))
instance (Internal.Data.Basic.Types.ForeignKeyConstraint fk, from ~ Internal.Data.Basic.Types.ForeignKeyFrom fk, to ~ Internal.Data.Basic.Types.ForeignKeyTo fk, Internal.Data.Basic.Types.TableField to toField, Internal.Data.Basic.Types.TableField from fromField, Internal.Data.Basic.Types.TableFieldType to toField ~ Internal.Data.Basic.Types.TableFieldType from fromField, Database.PostgreSQL.Simple.ToField.ToField (Internal.Data.Basic.Types.TableFieldType from fromField), GHC.Classes.Ord (Internal.Data.Basic.Types.TableFieldType to toField), Internal.Data.Basic.Types.KindOfDbExp (Internal.Data.Basic.Types.TableFieldType from fromField) ~ 'Internal.Data.Basic.Types.LiteralExp) => Internal.Data.Basic.Foreign.ForeignKeyFieldsMatch fk '[fromField] '[toField]
instance (from ~ Internal.Data.Basic.Types.ForeignKeyFrom fk, to ~ Internal.Data.Basic.Types.ForeignKeyTo fk, Internal.Data.Basic.Types.TableField to toField, Internal.Data.Basic.Types.TableField from fromField, Internal.Data.Basic.Types.TableFieldType to toField ~ Internal.Data.Basic.Types.TableFieldType from fromField, Database.PostgreSQL.Simple.ToField.ToField (Internal.Data.Basic.Types.TableFieldType from fromField), GHC.Classes.Ord (Internal.Data.Basic.Types.TableFieldType to toField), Internal.Data.Basic.Foreign.ForeignKeyFieldsMatch fk (f1 : f1s) (f2 : f2s), Internal.Data.Basic.Types.KindOfDbExp (Internal.Data.Basic.Types.TableFieldType from fromField) ~ 'Internal.Data.Basic.Types.LiteralExp) => Internal.Data.Basic.Foreign.ForeignKeyFieldsMatch fk (fromField : f1 : f1s) (toField : f2 : f2s)

module Internal.Data.Basic


-- | module Internal. : Data.Basic.TH.Types Description : Data types and
--   utility function used during TH generation phase License : MIT
--   
--   This module Internal.defines functions that are used to generate
--   Template Haskell code from AST. For AST description take a look at
--   <a>Types</a>.
module Internal.Data.Basic.TH.Generator

-- | Generates a data constructor for an entity
--   
--   <pre>
--   data Post = Post { _ostId     :: Key
--                    , _ostName   :: Text
--                    , _ostUserId :: Key } deriving (Show, Read, Generic)
--   </pre>
dataConstructor :: EntityInfo -> Dec

-- | Generates a fromRow instance for a entity.
--   
--   <pre>
--   instance FromRow Post where
--   fromRow = Post &lt;$&gt; field &lt;*&gt; field &lt;*&gt; field
--   </pre>
--   
--   fromRowInstance takes a name of the entity and a list of [a], which is
--   just used to count how many fields does the entity have - nothing
--   else. It generates something similar shown in a code snippet above - a
--   working FromRow instance for that datatype.
fromRowInstance :: Name -> [a] -> Dec

-- | Generates field optics for all entities
fieldOptics :: [EntityInfo] -> [Dec]

-- | Generates field optics for a column
--   
--   <pre>
--   name :: (FieldOptic "username" fun inType outType inVal outVal) =&gt; PolyOptic fun inType outType inVal outVal
--   name = fieldOpticProxy (Proxy :: Proxy "username")
--   </pre>
fieldOptic :: Text -> [Dec]

-- | Applies basic constraint depending on sql constraint If columns is
--   marked as primary or unique, add the <tt>Unique</tt> haskell datatype
fieldConstraint :: Constraint -> Maybe [Type]

-- | Generates a table field instance for a column
--   
--   <pre>
--   instance TableField Post "user_id" where
--     type TableFieldType Post "user_id" = Key
--     tableFieldLens = ostUserId
--   </pre>
tableField :: EntityInfo -> ColumnInfo -> Dec

-- | Generates required table field instances for all entities
tableFields :: [EntityInfo] -> [Dec]

-- | Generates final type for the sql column
finalType :: ColumnInfo -> Type

-- | Generates initial accessor for the table
--   
--   <pre>
--   allPosts = allRows (Proxy :: Proxy "post")
--   </pre>
initialAccessor :: EntityInfo -> [Dec]

-- | Generates foreign key optics
fkOptics :: [ForeignKeyConstraint] -> [Dec]

-- | Generates foreign key optic
--   
--   <pre>
--   author :: ForeignKeyLensProxy (Proxy "blog_post_author_fkey" -&gt; o) =&gt; o
--   author = foreignKeyLens @"blog_post_author_fkey"
--   </pre>
fkOptic :: ForeignKeyConstraint -> [Dec]

-- | Generates virtual table optics
virtualTables :: [ForeignKeyConstraint] -> [Dec]

-- | Generates virtual table optic
--   
--   <pre>
--   posts :: VirtualTable "blog_post_author_fkey" res
--      =&gt; Getter' (Entity ('FromDb c) (ForeignKeyTo "blog_post_author_fkey")) res
--   posts = virtualTableLensProxy (Proxy :: Proxy "blog_post_author_fkey")
--   </pre>
virtualTable :: ForeignKeyConstraint -> [Dec]

-- | Generates all constraint declarations from the <a>ParseContext</a>
allConstraints :: ParseContext -> [Dec]

-- | Generates unique key constraint instance
--   
--   <pre>
--   instance UniqueConstraint "blog_user_pkey" where
--      type UniqueTable "blog_user_pkey" = User
--      type UniqueFields "blog_user_pkey" = '["id"]
--   </pre>
uniqueConstraintInstance :: UniqueKeyConstraint -> [Dec]

-- | Generates primary key instance
--   
--   <pre>
--   instance PrimaryKeyConstraint "blog_user_pkey"
--   </pre>
primaryKeyInstance :: PrimaryKeyConstraint -> [Dec]

-- | Generates foreign key instance
--   
--   <pre>
--   instance ForeignKeyConstraint "blog_post_author_fkey" where
--   type ForeignKeyFrom "blog_post_author_fkey" = Post
--   type ForeignKeyFromFields "blog_post_author_fkey" = '["author"]
--   type ForeignKeyTo "blog_post_author_fkey" = User
--   type ForeignKeyToFields "blog_post_author_fkey" = '["id"]
--   </pre>
foreignKeyConstraint :: ForeignKeyConstraint -> Dec

-- | Generates a table instance for an entity from a <a>ParseContext</a>
--   
--   <pre>
--   instance Table Post where
--       type TableName Post = "blog_post"
--       type TableFields Post = ["id", "name", "author"]
--       type TableConstraints Post = '[]
--       type TablePrimaryKey Post = 'Nothing
--       type TableRequiredFields Post = ['DynamicDefault 'id, 'Required "name", 'Required "author"]
--   </pre>
tableInstance :: ParseContext -> EntityInfo -> [Dec]

-- | Generates a empty entity
--   
--   <pre>
--   newPost :: Entity ('Fresh ['DynamicDefault "id", 'Required "name", 'Required "author"])
--   newPost = Entity (Post 1 "" 1)
--   </pre>
emptyEntity :: ParseContext -> EntityInfo -> [Dec]

-- | Applies <tt>Required</tt> constraint to list of columns
required :: [ColumnInfo] -> [Type]

-- | Applies <tt>DynamicDefault</tt> constraint to a list of columns
dynamicDefault :: [ColumnInfo] -> [Type]

-- | Modifies column type depending on column constraints
applyConstraint :: ColumnInfo -> ColumnConstraint -> Type -> Type

-- | Generates coerce body. See <a>NullValue</a> why this is needed
coerceBody :: EntityInfo -> Body
nullValue' :: Int -> Exp -> Exp

-- | Generated the value representing the schema that can be applied to the
--   database
schemaValue :: Text -> Text -> [Dec]

module Internal.Data.Basic.TH.Compiler
compileSQL :: Text -> Q (Either ParseError [Statement])
compileContext :: ParseContext -> Q [Dec]
compileEntity :: ParseContext -> EntityInfo -> [Dec]
compileSQLStatements :: (Throws ParseError m, MonadIO m) => ParseContext -> [Statement] -> m ParseContext

-- | Updates <tt>CompileContext</tt> with data. The kind of data that is
--   being added depends on the statement being processed.
compileSQLStatement :: (Throws ParseError m, MonadIO m) => ParseContext -> Statement -> m ParseContext

-- | Updates <tt>CompileContext</tt> with constraints that have been added
--   using alter table
handleAlterTableOperations :: Throws ParseError m => ParseContext -> Name -> AlterTableAction -> m ParseContext

-- | Updates compile context from CREATE TABLE statement. Used when CREATE
--   TABLE statement is used. Adds to <tt>CompileContext</tt> any
--   constraints that are found and returns updated <a>EntityInfo</a> and
--   <tt>CompileContext</tt>
updateContext :: Throws ParseError m => ParseContext -> Name -> EntityInfo -> AttributeDef -> m (ParseContext, EntityInfo)

-- | Adds sql row constraints to compile context
compileRowConstraint :: Throws ParseError m => ParseContext -> EntityInfo -> ColumnInfo -> RowConstraint -> m (ParseContext, ColumnInfo)

-- | Adds sql constraint to compile context. If a sql constraint is
--   unnamed, it will be named.
compileConstraint :: Throws ParseError m => ParseContext -> EntityInfo -> Constraint -> m ParseContext

-- | Adds sql constraint to compile context.
compileConstraint' :: Throws ParseError m => ParseContext -> EntityInfo -> Constraint -> m ParseContext

module Internal.Data.Basic.TH

-- | Generates haskell code from an SQL file.
mkFromFile :: FilePath -> Q [Dec]

-- | Generates haskell code from multiple SQL files.
mkFromFiles :: [FilePath] -> Q [Dec]

-- | Allows you to print generated template haskell code to a file
printToFile :: [FilePath] -> FilePath -> Q [Dec]

module Data.Basic
data Key
data Point
Point :: {-# UNPACK #-} !Double -> {-# UNPACK #-} !Double -> Point
class (KnownSymbol (TableName table), AllSatisfy (TableField table) (TableFields table), AllSatisfy KnownSymbol (TableFields table), AllSatisfy (ValidConstraint table) (TableConstraints table), AllTypesSatisfy (TypeSatisfies ToField) table (TableFields table), OnMaybe (() :: Constraint) PrimaryKeyConstraint (TablePrimaryKey table), FromRow table) => Table table where {
    type family TableName table = (name :: Symbol) | name -> table;
    type family TableFields table :: [Symbol];
    type family TableConstraints table :: [FieldConstraint];
    type family TablePrimaryKey table :: Maybe Symbol;
    type family TableRequiredFields table :: [MissingField];
}
newEntity :: Table table => Entity ( 'Fresh (TableRequiredFields table)) table
class (KnownSymbol name, KnownSymbol (CapsName table name), IsDbExp (TableFieldType table name) ~  'False) => TableField (table :: *) (name :: Symbol) where {
    type family TableFieldType table name :: *;
    type family TableFieldCapsName table name :: Maybe Symbol;
    type TableFieldCapsName table name =  'Nothing;
}
tableFieldLens :: TableField table name => Lens' table (TableFieldType table name)
class (AllSatisfy (TableField (UniqueTable name)) (UniqueFields name), KnownSymbol name) => UniqueConstraint (name :: Symbol) where {
    type family UniqueTable name :: *;
    type family UniqueFields name :: [Symbol];
}
class (UniqueConstraint name, AllTypesSatisfy NotNull (UniqueTable name) (UniqueFields name)) => PrimaryKeyConstraint (name :: Symbol)
class (KnownSymbol name, AllSatisfy (TableField (ForeignKeyFrom name)) (ForeignKeyFromFields name), AllSatisfy (TableField (ForeignKeyTo name)) (ForeignKeyToFields name), SameTypes (ForeignKeyTo name) (ForeignKeyToFields name) (ForeignKeyFrom name) (ForeignKeyFromFields name)) => ForeignKeyConstraint (name :: Symbol) where {
    type family ForeignKeyFrom name :: *;
    type family ForeignKeyTo name :: *;
    type family ForeignKeyFromFields name :: [Symbol];
    type family ForeignKeyToFields name :: [Symbol];
}

-- | Defines <a>MissingField</a> kind.
data MissingField
Required :: Symbol -> MissingField
DynamicDefault :: Symbol -> MissingField
data FieldConstraint
Unique :: Symbol -> FieldConstraint
ForeignKey :: Symbol -> FieldConstraint
type AllRows table res = (Table table, LiftedStatement  'Unfiltered '[table] res)
newtype Entity (entKind :: EntityKind) a
Entity :: a -> Entity a
[$sel:_getEntity:Entity] :: Entity a -> a
data EntityKind
Fresh :: [MissingField] -> EntityKind
FromDb :: Cached -> EntityKind
type VirtualTable foreignKeyName res = (ForeignKeyConstraint foreignKeyName, AllFieldsMatch (ForeignKeyToFields foreignKeyName) (ForeignKeyFromFields foreignKeyName) (ForeignKeyTo foreignKeyName) (ForeignKeyFrom foreignKeyName), LiftedStatement  'Filtered '[(ForeignKeyFrom foreignKeyName)] res)
virtualTableLens :: forall foreignKeyName c res. VirtualTable foreignKeyName res => Getter' (Entity ( 'FromDb c) (ForeignKeyTo foreignKeyName)) (res)
type Getter' s a = PolyOptic (Const a) s s a a
class FieldOpticProxy t
fieldOptic :: forall name o. FieldOpticProxy (Proxy name -> o) => o
class ForeignKeyLensProxy t
foreignKeyLens :: forall name o. ForeignKeyLensProxy (Proxy name -> o) => o
class (Effect e, Monad m) => MonadEffect e (m :: * -> *)
data Basic
allRows :: forall tableName table res. (TableName table ~ tableName, AllRows table res) => res
ddelete :: (LiftedStatement  'Deleted '[table] res, Selection f, Table table) => DbStatement f '[table] -> res
dupdate :: (MonadEffect Basic m, FromRow table, Selection f) => (Var  'Updating table -> UpdateExp fields table) -> DbStatement f '[table] -> m [Entity ( 'FromDb  'Live) table]
insert :: (CanInsert entKind table, MonadEffect Basic m, FromRow table) => Entity entKind table -> m (Entity ( 'FromDb  'Live) table)
dfilter :: (LiftedStatement  'Filtered tables res, TableSetVars  'Filtering tables, Selection f) => (Variables  'Filtering tables -> ConditionExp) -> DbStatement f tables -> res
save :: forall table pk fields c m. (Table table, 'Just pk ~ TablePrimaryKey table, fields ~ UniqueFields pk, PrimaryKeyMatch fields table, SetAllFields (TableFields table) table, MonadEffect Basic m) => Entity ( 'FromDb c) table -> m (Entity ( 'FromDb  'Live) table)
dtake :: (LiftedStatement  'Limited tables res, CanTake f) => Int -> DbStatement f tables -> res
djoin :: LiftedStatement  'Unfiltered (tables1 ++ tables2) res => DbStatement  'Unfiltered tables1 -> DbStatement  'Unfiltered tables2 -> res
dsortOn :: (LiftedStatement  'Sorted tables res, TableSetVars  'Sorting tables, Sortable ord, Selection f) => (Variables  'Sorting tables -> ord) -> DbStatement f tables -> res
dfoldMap :: forall tables aggr f res. (Aggregatable aggr, CanAggregate f, TableSetVars  'Folding tables, LiftedAggregation (InterpretAsGroupMap res) aggr res) => (Variables  'Folding tables -> aggr) -> DbStatement f tables -> res
dfoldMapInner :: (AsAggregate group ~ GroupMappableThing t  'AM, LiftedMapStatement  'Folded (ListToSimpleTuple (TupleToList t ++ TupleToList (AggregationResult aggr))) res, Aggregatable aggr, TableSetVars  'Folding tables) => (Variables  'Folding tables -> aggr) -> GroupStatement group tables -> res
dmap :: forall f res a b m (ts :: [*]) t. (Dmap' ((a -> b) -> m ts -> DbStatement f '[t]), LiftedMapStatement f t res) => (a -> b) -> m ts -> res
dgroupOn :: (Groupable group, TableSetVars  'Grouping tables, Selection f) => (Variables  'Grouping tables -> group) -> DbStatement f tables -> GroupStatement group tables
rawQuery :: forall a r m. (MonadEffect Basic m, FromRow a, ToRow r) => Text -> r -> m [Entity ( 'FromDb  'Live) a]
(<.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 <.
(>.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 >.
(==.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 ==.
(/=.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 /=.
(<=.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 <=.
(>=.) :: ComparableInDbExp a b => a -> b -> ConditionExp
infix 4 >=.
(&&.) :: ConditionExp -> ConditionExp -> ConditionExp
infixr 3 &&.
(||.) :: ConditionExp -> ConditionExp -> ConditionExp
infixr 2 ||.
data ConditionExp
[In] :: LiteralCollection collection a => DbExp k a -> collection -> ConditionExp
newtype Avg a
Avg :: a -> Avg a
newtype Count a
Count :: a -> Count a
newtype Min a :: * -> *
Min :: a -> Min a
[getMin] :: Min a -> a
newtype Max a :: * -> *
Max :: a -> Max a
[getMax] :: Max a -> a

-- | Monoid under addition.
newtype Sum a :: * -> *
Sum :: a -> Sum a
[getSum] :: Sum a -> a
newtype List a
List :: a -> List a

-- | Wrap a list for use as a PostgreSQL array.
newtype PGArray a :: * -> *
PGArray :: [a] -> PGArray a
[fromPGArray] :: PGArray a -> [a]

-- | Handles SQL by querying a PostgreSQL database. Writes logs to console.
handleBasicPsql :: MonadIO m => Connection -> RuntimeImplemented Basic (RuntimeImplemented Logging (ExceptT BasicException m)) a -> m a

-- | Attempt to make a connection based on a libpq connection string. See
--   <a>https://www.postgresql.org/docs/9.5/static/libpq-connect.html#LIBPQ-CONNSTRING</a>
--   for more information. Also note that environment variables also affect
--   parameters not provided, parameters provided as the empty string, and
--   a few other things; see
--   <a>https://www.postgresql.org/docs/9.5/static/libpq-envars.html</a>
--   for details. Here is an example with some of the most commonly used
--   parameters:
--   
--   <pre>
--   host='db.somedomain.com' port=5432 ...
--   </pre>
--   
--   This attempts to connect to <tt>db.somedomain.com:5432</tt>. Omitting
--   the port will normally default to 5432.
--   
--   On systems that provide unix domain sockets, omitting the host
--   parameter will cause libpq to attempt to connect via unix domain
--   sockets. The default filesystem path to the socket is constructed from
--   the port number and the <tt>DEFAULT_PGSOCKET_DIR</tt> constant defined
--   in the <tt>pg_config_manual.h</tt> header file. Connecting via unix
--   sockets tends to use the <tt>peer</tt> authentication method, which is
--   very secure and does not require a password.
--   
--   On Windows and other systems without unix domain sockets, omitting the
--   host will default to <tt>localhost</tt>.
--   
--   <pre>
--   ... dbname='postgres' user='postgres' password='secret \' \\ pw'
--   </pre>
--   
--   This attempts to connect to a database named <tt>postgres</tt> with
--   user <tt>postgres</tt> and password <tt>secret ' \ pw</tt>. Backslash
--   characters will have to be double-quoted in literal Haskell strings,
--   of course. Omitting <tt>dbname</tt> and <tt>user</tt> will both
--   default to the system username that the client process is running as.
--   
--   Omitting <tt>password</tt> will default to an appropriate password
--   found in the <tt>pgpass</tt> file, or no password at all if a matching
--   line is not found. See
--   <a>https://www.postgresql.org/docs/9.5/static/libpq-pgpass.html</a>
--   for more information regarding this file.
--   
--   As all parameters are optional and the defaults are sensible, the
--   empty connection string can be useful for development and exploratory
--   use, assuming your system is set up appropriately.
--   
--   On Unix, such a setup would typically consist of a local postgresql
--   server listening on port 5432, as well as a system user, database
--   user, and database sharing a common name, with permissions granted to
--   the user on the database.
--   
--   On Windows, in addition you will either need <tt>pg_hba.conf</tt> to
--   specify the use of the <tt>trust</tt> authentication method for the
--   connection, which may not be appropriate for multiuser or production
--   machines, or you will need to use a <tt>pgpass</tt> file with the
--   <tt>password</tt> or <tt>md5</tt> authentication methods.
--   
--   See
--   <a>https://www.postgresql.org/docs/9.5/static/client-authentication.html</a>
--   for more information regarding the authentication process.
--   
--   SSL/TLS will typically "just work" if your postgresql server supports
--   or requires it. However, note that libpq is trivially vulnerable to a
--   MITM attack without setting additional SSL connection parameters. In
--   particular, <tt>sslmode</tt> needs to be set to <tt>require</tt>,
--   <tt>verify-ca</tt>, or <tt>verify-full</tt> in order to perform
--   certificate validation. When <tt>sslmode</tt> is <tt>require</tt>,
--   then you will also need to specify a <tt>sslrootcert</tt> file,
--   otherwise no validation of the server's identity will be performed.
--   Client authentication via certificates is also possible via the
--   <tt>sslcert</tt> and <tt>sslkey</tt> parameters. See
--   <a>https://www.postgresql.org/docs/9.5/static/libpq-ssl.html</a> for
--   detailed information regarding libpq and SSL.
connectPostgreSQL :: ByteString -> IO Connection

-- | Handles SQL by querying a PostgreSQL database. Leaves logs unhandled.
handleBasicPsqlWithLogging :: forall m a. (MonadEffects '[Logging, Signal BasicException Query] m, MonadIO m) => Connection -> RuntimeImplemented Basic m a -> m a
data BasicException
BasicFormatError :: FormatError -> BasicException
BasicQueryError :: QueryError -> BasicException
BasicResultError :: ResultError -> BasicException
BasicSqlError :: SqlError -> BasicException
throwBasicToIO :: forall m a. MonadIO m => ExceptT BasicException m a -> m a
logOnlyErrors :: MonadEffect Logging m => RuntimeImplemented Logging m a -> m a

-- | Print out the logs in rich format. Truncates at the given length. Logs
--   will contain: message, timestamp, data, user and the call stack.
prettyPrintSummary :: MonadIO m => Int -> RuntimeImplemented Logging m a -> m a

-- | Generates haskell code from an SQL file.
mkFromFile :: FilePath -> Q [Dec]

-- | Generates haskell code from multiple SQL files.
mkFromFiles :: [FilePath] -> Q [Dec]

-- | Allows you to print generated template haskell code to a file
printToFile :: [FilePath] -> FilePath -> Q [Dec]

-- | A collection type that can be converted from a sequence of fields.
--   Instances are provided for tuples up to 10 elements and lists of any
--   length.
--   
--   Note that instances can be defined outside of postgresql-simple, which
--   is often useful. For example, here's an instance for a user-defined
--   pair:
--   
--   <pre>
--   data User = User { name :: String, fileQuota :: Int }
--   
--   instance <a>FromRow</a> User where
--       fromRow = User &lt;$&gt; <a>field</a> &lt;*&gt; <a>field</a>
--   </pre>
--   
--   The number of calls to <a>field</a> must match the number of fields
--   returned in a single row of the query result. Otherwise, a
--   <a>ConversionFailed</a> exception will be thrown.
--   
--   Note that <a>field</a> evaluates its result to WHNF, so the caveats
--   listed in mysql-simple and very early versions of postgresql-simple no
--   longer apply. Instead, look at the caveats associated with
--   user-defined implementations of <a>fromField</a>.
class FromRow a
fromRow :: FromRow a => RowParser a
field :: FromField a => RowParser a
data Cached
Live :: Cached
Cached :: Cached
delem :: (LiteralCollection collection a) => DbExp k a -> collection -> ConditionExp
disNothing :: DbExp  'FieldExp (Maybe a) -> ConditionExp
disJust :: DbExp  'FieldExp (Maybe a) -> ConditionExp
type GettableField entKind field = FieldIsGettable field (MissingFields entKind)

-- | A field that's settable, but also potentially gettable (if it's
--   already set). If it is gettable then you can modify it, otherwise you
--   can just set it.
type ModifyableField table entKind field = SupportedModifyAccess (FieldIsGettableBool field (MissingFields entKind)) (TableFieldType table field)

-- | A synonym for ModifyableField. It still checks if the field is already
--   set.
type SettableField table entKind field = ModifyableField table entKind field
like :: DbExp  'FieldExp Text -> Text -> ConditionExp
ilike :: DbExp  'FieldExp Text -> Text -> ConditionExp
dtrue :: ConditionExp
dfalse :: ConditionExp
executeQuery :: (ToRow r, MonadEffect Basic m) => Text -> r -> m ()
applySchema :: MonadEffect Basic m => Schema -> m ()
data Schema
toFreshEntity :: forall fs c a. Entity ( 'FromDb c) a -> Entity ( 'Fresh fs) a


-- | This tutorial describes how to use the basic library. Usually you
--   would use the functions provided in the Internal.Data.Basic.TH module
--   (re-exported by Data.Basic) to generate all of the declarations in
--   this tutorial from your database schema.
--   
--   Basic is a database-first library meaning the schema comes from the
--   database instead of your code. The library provides mechanisms for
--   "explaining" your schema to the compiler. It can then use this
--   information to provide a typesafe and convenient access and control of
--   your data.
--   
--   We start by defining a data type.
--   
--   <pre>
--   data User = User { _serId   :: <a>Key</a>
--                    , _serName :: <a>Text</a> } deriving (<a>Eq</a>, <a>Ord</a>, <a>Read</a>, <a>Show</a>)
--   
--   </pre>
--   
--   Most of the functionality is implemented through lenses so we need to
--   generate them for our datatype.
--   
--   <pre>
--   <a>makeLenses</a> ''User
--   
--   </pre>
--   
--   Next we provide a set of instances for our type. These describe how
--   our type maps to a database table. We use type level strings to
--   represent database names of the fields. Instances are needed for each
--   field and for each constraint on the table. We also need a
--   <a>FromRow</a> instance so the type can actually be deserialized from
--   the query result.
--   
--   <pre>
--   instance <a>Table</a> User where
--       -- the database name for this table
--       type <a>TableName</a> User = "blog_user"
--   
--       -- a type level list of all the fields in this table
--       type <a>TableFields</a> User = ["id", "name"]
--   
--       -- a type level list of constraints on this table; each of these will need a corresponding
--       -- instance that provides additional info
--       type <a>TableConstraints</a> User = '[ '<a>Unique</a> "blog_user_pkey"]
--   
--       -- the table can optionally have a primary key; for this we use a type level <a>Maybe</a> value
--       type <a>TablePrimaryKey</a> User = '<a>Just</a> "blog_user_pkey"
--   
--       -- a type level list of fields that are either <a>Required</a> or <a>DynamicDefault</a>
--       type <a>TableRequiredFields</a> User = ['<a>Required</a> "id", '<a>Required</a> "name"]
--   
--       -- a default user
--       -- don't worry about undefined values, the types will make sure you can't accidentally evaluate
--       -- them
--       <a>newEntity</a> = <a>Entity</a> (User <a>undefined</a> <a>undefined</a>)
--   
--   instance <a>UniqueConstraint</a> "blog_user_pkey" where
--       -- the table which this constraint targets
--       type <a>UniqueTable</a> "blog_user_pkey" = User
--   
--       -- you can have multiple fields that make up one unique constraint
--       type <a>UniqueFields</a> "blog_user_pkey" = '["id"]
--   
--   -- <a>PrimaryKeyConstraint</a> is really just a synonym for a unique constraint + the condition that
--   -- all the values must not be null
--   instance <a>PrimaryKeyConstraint</a> "blog_user_pkey"
--   
--   -- each field gets an instance saying what Haskell type it maps to and providing a lens
--   instance <a>TableField</a> User "id" where
--       type <a>TableFieldType</a> User "id" = <a>Key</a>
--       <a>tableFieldLens</a> = serId
--   
--   instance <a>TableField</a> User "name" where
--       type <a>TableFieldType</a> User "name" = <a>Text</a>
--       <a>tableFieldLens</a> = serName
--   
--   instance <a>FromRow</a> User where
--       <a>fromRow</a> = User <a>&lt;$&gt;</a> field <a>&lt;*&gt;</a> field
--   
--   </pre>
--   
--   Now we do the same for a "blog_post" table.
--   
--   <pre>
--   data Post = Post { _ostId     :: <a>Key</a>
--                    , _ostName   :: <a>Text</a>
--                    , _ostUserId :: <a>Key</a> } deriving (<a>Eq</a>, <a>Ord</a>, <a>Read</a>, <a>Show</a>)
--   
--   instance <a>Table</a> Post where
--       type <a>TableName</a> Post = "blog_post"
--       type <a>TableFields</a> Post = ["id", "name", "author"]
--       type <a>TableConstraints</a> Post = '[ '<a>ForeignKey</a> "blog_post_author_fkey"]
--       type <a>TablePrimaryKey</a> Post = '<a>Just</a> "blog_post_pkey"
--       type <a>TableRequiredFields</a> Post = ['<a>Required</a> "id", '<a>Required</a> "name", '<a>Required</a> "author"]
--       <a>newEntity</a> = <a>Entity</a> (Post <a>undefined</a> <a>undefined</a>)
--   
--   instance <a>UniqueConstraint</a> "blog_post_pkey" where
--       type <a>UniqueTable</a> "blog_post_pkey" = Post
--       type <a>UniqueFields</a> "blog_post_pkey" = '["id"]
--   
--   instance <a>PrimaryKeyConstraint</a> "blog_post_pkey"
--   
--   instance <a>FromRow</a> Post where
--       fromRow = Post <a>&lt;$&gt;</a> field <a>&lt;*&gt;</a> field <a>&lt;*&gt;</a> field
--   <a>makeLenses</a> ''Post
--   
--   instance <a>TableField</a> Post "id" where
--       type <a>TableFieldType</a> Post "id" = <a>Key</a>
--       <a>tableFieldLens</a> = ostId
--   
--   instance <a>TableField</a> Post "name" where
--       type <a>TableFieldType</a> Post "name" = <a>Text</a>
--       <a>tableFieldLens</a> = ostName
--   
--   instance <a>TableField</a> Post "author" where
--       type <a>TableFieldType</a> Post "author" = <a>Key</a>
--       <a>tableFieldLens</a> = ostUserId
--   
--   </pre>
--   
--   Next, we declare a foreign key from the post table to the user table.
--   The instance is more or less self explanatory.
--   
--   <pre>
--   instance <a>ForeignKeyConstraint</a> "blog_post_author_fkey" where
--       type <a>ForeignKeyFrom</a> "blog_post_author_fkey" = Post
--       type <a>ForeignKeyFromFields</a> "blog_post_author_fkey" = '["author"]
--       type <a>ForeignKeyTo</a> "blog_post_author_fkey" = User
--       type <a>ForeignKeyToFields</a> "blog_post_author_fkey" = '["id"]
--   
--   </pre>
--   
--   Now we're ready to create the lenses and values that we'll use to
--   manipulate our data. Again, keep in mind that all of this can be
--   generated for you via the TH functions, directly from your SQL schema.
--   
--   <pre>
--   -- this value will represent a virtual "list" of all the users in the database
--   allUsers :: <a>AllRows</a> User m r =&gt; m r
--   allUsers = <a>allRows</a> <tt>"blog_user"
--   
--   -- this is the same, but for posts
--   allPosts :: <a>AllRows</a> Post m r =&gt; m r
--   allPosts = <a>allRows</a> </tt>"blog_post"
--   
--   -- we use this value to construct new users
--   newUser :: <a>Entity</a> ('<a>Fresh</a> ['<a>Required</a> "id", '<a>Required</a> "name"]) User
--   newUser = <a>newEntity</a>
--   
--   newPost :: <a>Entity</a> ('<a>Fresh</a> ['<a>Required</a> "id", '<a>Required</a> "name", '<a>Required</a> "author"]) Post
--   newPost = <a>newEntity</a>
--   
--   -- we can use this lens to get all posts belonging to some author
--   posts :: <a>VirtualTable</a> "blog_post_author_fkey" m r
--         =&gt; 'Getter'\' (<a>Entity</a> ('<a>FromDb</a> c) (<a>ForeignKeyTo</a> "blog_post_author_fkey")) (m r)
--   posts = <a>virtualTableLens</a> <tt>"blog_post_author_fkey"
--   
--   -- a lens to access the id field of any table that has it; same for name and authorId
--   id :: <a>FieldOpticProxy</a> (<a>Proxy</a> "id" -&gt; o) =&gt; o
--   id = <a>fieldOptic</a> </tt>"id"
--   
--   name :: <a>FieldOpticProxy</a> (<a>Proxy</a> "name" -&gt; o) =&gt; o
--   name = <a>fieldOptic</a> <tt>"name"
--   
--   authorId :: <a>FieldOpticProxy</a> (<a>Proxy</a> "author" -&gt; o) =&gt; o
--   authorId = <a>fieldOptic</a> </tt>"author"
--   
--   -- this lens will let us get the actual user value from a post, through the foreign key
--   author :: <a>ForeignKeyLensProxy</a> (<a>Proxy</a> "blog_post_author_fkey" -&gt; o) =&gt; o
--   author = <a>foreignKeyLens</a> @"blog_post_author_fkey"
--   
--   </pre>
--   
--   Finally, we get to a usage example.
--   
--   <pre>
--   test1 :: (<a>MonadIO</a> m, <a>MonadEffect</a> <a>Basic</a> m) =&gt; m ()
--   test1 = do
--       <a>void</a> $ <a>ddelete</a> allPosts
--       <a>void</a> $ <a>ddelete</a> allUsers
--   
--       -- we use the lens to construct values
--       let user = newUser <a>&amp;</a> name <a>.~</a> <a>John</a>
--                          <a>&amp;</a> id <a>.~</a> 1
--   
--       -- check this out: try not setting one of the fields on user
--       -- the compiler will not let you insert the value into the database
--       user &lt;- <a>insert</a> user
--       let post = newPost <a>&amp;</a> id <a>.~</a> 1
--                          <a>&amp;</a> name <a>.~</a> "New post"
--                          <a>&amp;</a> author <a>.~</a> user
--       post &lt;- <a>insert</a> post
--   
--       -- to access our data we use functions like <a>dfilter</a> and pretend we're dealing with
--       -- lists of values
--       users &lt;- <a>dfilter</a> (\u -&gt; (u <a>^.</a> id) <a>In</a> [1, 3, 4]) allUsers
--   
--       -- get the author of a post, update the name and save it to the database
--       auth &lt;- post <a>^.</a> author
--       <a>void</a> $ <a>save</a> (auth <a>&amp;</a> name <a>.~</a> "John H")
--   
--       let user2 = newUser <a>&amp;</a> name <a>.~</a> <a>Mike</a>
--                           <a>&amp;</a> id <a>.~</a> 2
--       <a>void</a> $ <a>insert</a> user2
--   
--       -- sorting and taking works just like lists do, at least syntactically
--       -- the semantics still need to be translated to SQL so first taking, then sorting won't
--       -- compile
--       -- you can use the usual Down newtype for switching from ascending to descending
--       us &lt;- <a>dtake</a> 1 $ <a>dsortOn</a> (\u -&gt; <a>Down</a> (u <a>^.</a> id)) allUsers
--       <a>print</a> us
--   
--       -- dupdate is like mapM
--       <a>void</a> $ <a>dupdate</a> (\u' -&gt; u' <a>&amp;</a> id <a>.~</a> (2 :: <a>Key</a>)) allUsers
--   
--       [mike] &lt;- <a>dfilter</a> (\u' -&gt; u' <a>^.</a> id <a>==.</a> (1 :: <a>Key</a>)) allUsers
--       -- here we're using that special virtual table lens to get a list of all posts by Mike
--       psts &lt;- mike <a>^.</a> posts
--       -- we can also filter on that list like it's a table in the database
--       somePsts &lt;- dfilter (\p -&gt; p <a>^.</a> id <a>==.</a> (0 :: <a>Key</a>)) (mike <a>^.</a> posts)
--   
--       -- joins are done with the djoin function; the resulting list can also be filtered
--       usersPosts &lt;- allUsers <a>djoin</a> allPosts
--       print usersPosts
--   
--   test :: <a>IO</a> ()
--   test = do
--       conn &lt;- <a>connectPostgreSQL</a> "host=localhost port=5432 user=postgres dbname=postgres password=admin connect_timeout=10"
--       <a>handleBasicPsql</a> conn test1
--   
--   </pre>
module Data.Basic.Tutorial

module Data.Basic.Example
data User
User :: {-# UNPACK #-} !Key -> {-# UNPACK #-} !Text -> Point -> User
[$sel:_userId:User] :: User -> {-# UNPACK #-} !Key
[$sel:_userName:User] :: User -> {-# UNPACK #-} !Text
[$sel:_userLocation:User] :: User -> Point
userName :: Lens' User Text
userLocation :: Lens' User Point
userId :: Lens' User Key
data Post
Post :: Key -> Text -> Key -> Post
[$sel:_postId:Post] :: Post -> Key
[$sel:_postName:Post] :: Post -> Text
[$sel:_postUserId:Post] :: Post -> Key
postUserId :: Lens' Post Key
postName :: Lens' Post Text
postId :: Lens' Post Key
allUsers :: AllRows User res => res
allPosts :: AllRows Post res => res
newUser :: Entity ( 'Fresh [ 'Required "id", 'Required "name", 'Required "location"]) User
newPost :: Entity ( 'Fresh [ 'Required "id", 'Required "name", 'Required "author"]) Post
posts :: VirtualTable "blog_post_author_fkey" res => Getter' (Entity ( 'FromDb c) (ForeignKeyTo "blog_post_author_fkey")) res
id :: FieldOpticProxy (Proxy "id" -> o) => o
name :: FieldOpticProxy (Proxy "name" -> o) => o
location :: FieldOpticProxy (Proxy "location" -> o) => o
authorId :: FieldOpticProxy (Proxy "author" -> o) => o
author :: ForeignKeyLensProxy (Proxy "blog_post_author_fkey" -> o) => o
test1 :: (MonadIO m, MonadEffect Basic m) => m ()
test :: IO ()
putQ :: Show a => Q a -> IO ()
putQLn :: Show a => Q a -> IO ()
instance Internal.Data.Basic.Types.Table Data.Basic.Example.Post
instance Internal.Data.Basic.Types.UniqueConstraint "blog_post_pkey"
instance Internal.Data.Basic.Types.PrimaryKeyConstraint "blog_post_pkey"
instance Database.PostgreSQL.Simple.FromRow.FromRow Data.Basic.Example.Post
instance Internal.Data.Basic.Types.TableField Data.Basic.Example.Post "id"
instance Internal.Data.Basic.Types.TableField Data.Basic.Example.Post "name"
instance Internal.Data.Basic.Types.TableField Data.Basic.Example.Post "author"
instance Internal.Data.Basic.Types.ForeignKeyConstraint "blog_post_author_fkey"
instance GHC.Show.Show Data.Basic.Example.Post
instance GHC.Read.Read Data.Basic.Example.Post
instance GHC.Classes.Ord Data.Basic.Example.Post
instance GHC.Classes.Eq Data.Basic.Example.Post
instance Internal.Data.Basic.Types.Table Data.Basic.Example.User
instance Internal.Data.Basic.Types.UniqueConstraint "blog_user_pkey"
instance Internal.Data.Basic.Types.PrimaryKeyConstraint "blog_user_pkey"
instance Internal.Data.Basic.Types.TableField Data.Basic.Example.User "id"
instance Internal.Data.Basic.Types.TableField Data.Basic.Example.User "name"
instance Internal.Data.Basic.Types.TableField Data.Basic.Example.User "location"
instance Database.PostgreSQL.Simple.FromRow.FromRow Data.Basic.Example.User
instance GHC.Show.Show Data.Basic.Example.User
instance GHC.Read.Read Data.Basic.Example.User
instance GHC.Classes.Eq Data.Basic.Example.User