h$(*      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred./x Safe-Inferred/ %rel8Map a  Type -> Type function over the Type1-kinded type variables in of a type constructor.None./>? b  Safe-Inferred'(/?  None< rel8An ordering expression for a(. Primitive orderings are defined with   and  , and you can combine Order via its various instances.A common pattern is to use 1 to combine multiple orderings in sequence, and   to select individual columns.None  Safe-Inferred'(-. Z Safe-Inferred  Safe-Inferred/  Safe-Inferred'(-/>?rel8The Sql type class describes both null and not null database values, constrained by a specific class.For example, if you see  Sql DBEq a<, this means any database type that supports equality, and a can either be exactly an a, or it could also be Maybe a.rel8 Nullable a means that rel8 is able to check if the type a is a type that can take null values or not.rel8Homonullable a b means that both a and b can be null, or neither a or b can be null.rel8 nullify a means a cannot take null as a value.  Safe-Inferred#%5<Grel8The schema for a table. This is used to specify the name and schema that a table belongs to (the FROM part of a SQL query), along with the schema of the columns within this table.For each selectable table in your database, you should provide a  TableSchema. in order to interact with the table via Rel8.rel8The name of the table. rel8*The schema that this table belongs to. If #, whatever is on the connection's  search_path will be used. rel8The columns of the table. Typically you would use a a higher-kinded data type here, parameterized by the  functor. None%'(" rel8TypeInformation describes how to encode and decode a Haskell type to and from database queries. The typeName is the name of the type in the database, which is used to accurately type literals. rel89How to encode a single Haskell value as a SQL expression.rel83How to deserialize a single result back to Haskell.rel8The name of the SQL type.rel8Simultaneously map over how a type is both encoded and decoded, while retaining the name of the type. This operation is useful if you want to essentially newtype another .The mapping is required to be total. If you have a partial mapping, see .rel8Apply a parser to  .This can be used if the data stored in the database should only be subset of a given  . The parser is applied when deserializing rows returned - the encoder assumes that the input data is already in the appropriate form. None %&'(ONone>?@rel8Haskell types that can be represented as expressions in a database. There should be an instance of DBType6 for all column types in your database schema (e.g., int,  timestamptz, etc).Rel8 comes with stock instances for most default types in PostgreSQL, so you should only need to derive instances of this class for custom database types, such as types defined in PostgreSQL extensions, or custom domain types.rel8Corresponds to jsonbrel8Corresponds to uuidrel8Corresponds to bytearel8Corresponds to bytearel8Corresponds to citextrel8Corresponds to citextrel8Corresponds to textrel8Corresponds to textrel8Corresponds to intervalrel8Corresponds to timerel8Corresponds to  timestamprel8Corresponds to daterel8Corresponds to  timestamptzrel8Corresponds to numericrel8Corresponds to float8rel8Corresponds to float4rel8Corresponds to int8rel8Corresponds to int4rel8Corresponds to int2rel8Corresponds to charrel8Corresponds to boolNone>?.rel8Database types that can be compared for equality in queries. If a type is an instance of , it means we can compare expressions for equality using the SQL = operator.None?QNone %'(/hrel8The Result7 context is the context used for decoded query results.When a query is executed against a PostgreSQL database, Rel8 parses the returned rows, decoding each row into the Result context.None/rel8/This type family is used to specify columns in Rel8ables. In  Column f a, f is the context of the column (which should be left polymorphic in Rel8able definitions), and a is the type of the column.None/9>?rel8A HTable is a functor-indexed/higher-kinded data type that is representable (/), constrainable (), and specified ().This is an internal concept for Rel8, and you should not need to define instances yourself or specify this constraint.  None'(+-/0>G !None#$%'(-/8:<>rel8 Transform a  by allowing it to be null."None #$/ #None./>? e $None+/> %None/? &None/9>?$rel8Tables are one of the foundational elements of Rel8, and describe data types that have a finite number of columns. Each of these columns contains data under a shared context, and contexts describe how to interpret the metadata about a column to a particular Haskell type. In Rel8, we have contexts for expressions (the ' context), aggregations (the ( context), insert values (the ) contex), among others.?In typical usage of Rel8 you don't need to derive instances of . yourself, as anything that's an instance of * is always a .rel8The 1 functor that describes the schema of this table.rel8=The common context that all columns use as an interpretation.rel8The  FromExprs type family maps a type in the Expr, context to the corresponding Haskell type. +None />&!rel8! from to a b means that a and b are  s, in the from and to contexts respectively, which share the same underlying structure. In other words, b is a version of a transposed from the from context to the to context (and vice versa).!,None />&?-None /?&"rel8.A special context used in the construction of .s."/None>?)t#rel8# p means that p is a kind of bifunctor on 0's that allows the mapping of a pair of ' s over its underlying columns.$rel8Map a pair of 's over p.%rel8% f means that f is a kind of functor on 0 s that allows the mapping of a ' over its underlying columns.&rel8Map a ' over f.'rel8A ' a b s is a special type of function a -> b whereby the resulting b> is guaranteed to be composed only from columns contained in a.(rel8The constraint ( a b ensures that ' a b is a usable '.#$%&'(1None#$'(-/8:<>?)2None/)3None/*4None%?+)rel89Cast an expression to a different type. Corresponds to a CAST() function call.*rel82Unsafely construct an expression from literal SQL.This is an escape hatch, and can be used if Rel8 can not adequately express the query you need. If you find yourself using this function, please let us know, as it may indicate that something is missing from Rel8! )*5None%?,+rel8%Produce an expression from a literal.Note that you can usually use 6, but litExpr6 can solve problems of inference in polymorphic code.+7None >?.,rel8 This type class exists to allow - to have arbitrary arity. It's mostly an implementation detail, and typical uses of ,& shouldn't need this to be specified.-rel8-Construct an n-ary function that produces an ' that when called runs a SQL function..rel8:Construct a function call for functions with no arguments./rel8Construct an expression by applying an infix binary operator to two operands.,-./8None'(2y 0rel8The SQL false literal.1rel8The SQL true literal.2rel8The SQL AND operator.3rel8The SQL OR operator.4rel8The SQL NOT operator.5rel8Fold AND" over a collection of expressions.6rel8Fold OR" over a collection of expressions.7rel8&Eliminate a boolean-valued expression.Corresponds to 9:.8rel8A multi-way ifthen&else statement. The first argument to caseExpr is a list of alternatives. The first alternative that is of the form  (true, x) will be returned. If no such alternative is found, a fallback expression is returned.Corresponds to a CASE expression in SQL.9rel8 Convert a Expr (Maybe Bool) to a  Expr Bool by treating Nothing as False(. This can be useful when combined with ;, which expects a Bool, and produces expressions that optimize better than general case analysis. 01234567892332<None/?6:rel8!Lift an expression that can't be null to a type that might be null. This is an identity operation in terms of any generated query, and just modifies the query's type.rel8Like , but to eliminate null.;rel8Like => , but for null.<rel8Like =? , but for null.=rel8Lift an operation on non-null$ values to an operation on possibly null values. When given null,  mapNull f returns null. This is like  for .>rel8Lift a binary operation on non-null; expressions to an equivalent binary operator on possibly null4 expressions. If either of the final arguments are null,  liftOpNull returns null. This is like liftA2 for .?rel8Corresponds to SQL null. :;<=>?@None/?6IANone6@rel8Like B, but works for jsonb columns.@ABCNone7~Crel8A deriving-via helper type for column types that store a Haskell value using a JSON encoding described by aeson's  and  type classes.CDEDNone />?9uFrel8-The class of database types that support the / operator.Grel8-The class of database types that support the / operator.Hrel8The class of database types that can be coerced to from integral expressions. This is a Rel8 concept, and allows us to provide .Irel8-The class of database types that support the +, *, - operators, and the abs, negate, sign functions.FGHIENone>?:Jrel8-The class of database types that support the min aggregation function.Krel8-The class of database types that support the max aggregation function.Lrel8-The class of database types that support the <, <=, > and >= operators.JKLFNone/>??)Mrel8Types that are sum types, where each constructor is unary (that is, has no fields).Nrel8DBEnum: contains the necessary metadata to describe a PostgreSQL enum type.Orel87Map Haskell values to the corresponding element of the enum type. The default implementation of this method will use the exact name of the Haskell constructors.Prel8The name of the PostgreSQL enum type that a maps to.Qrel8A deriving-via helper type for column types that store an "enum" type (in Haskell terms, a sum type where all constructors are nullary) using a Postgres enum type.Note that this should map to a specific type in your database's schema (explicitly created with CREATE TYPE ... AS ENUM). Use N to specify the name of this Postgres type and the names of the individual values. If left unspecified, the names of the values of the Postgres enum are assumed to match exactly exactly the names of the constructors of the Haskell type (up to and including case sensitivity).MNOPQRGNone&?Srel8A deriving-via helper type for column types that store a Haskell value using a Haskell's  and  type classes.STUHNone +/>?@Vrel8 The class of s that form a semigroup. This class is purely a Rel8 concept, and exists to mirror the  Semigroup class.Wrel8An associative operation.VWW6INone  />?AXrel8 The class of s that form a semigroup. This class is purely a Rel8 concept, and exists to mirror the  class.XYJNone/<>?Arel8Typed SQL expressions.KNone%?B LNone%>?DZrel8 Serializable; witnesses the one-to-one correspondence between the type sql/, which contains SQL expressions, and the type haskell:, which contains the Haskell decoding of rows containing sql SQL expressions.[rel8ToExprs exprs a is evidence that the types exprs and a* describe essentially the same type, but exprs is in the  context, and a is a normal Haskell type.\rel8Use lit2 to turn literal Haskell values into expressions. lit is capable of lifting single Exprs to full tables.Z[\MNone&?Ff]rel8%An if-then-else expression on tables. bool x y p returns x if p is False, and returns y if p is True.^rel8Produce a table expression from a list of alternatives. Returns the first table where the  Expr Bool expression is True>. If no alternatives are true, the given default is returned._rel8Like , but to eliminate null.]^_NNone?Hh`rel8Like  Alternative in Haskell, some )s form a monoid on applicative functors.arel8The identity of c.brel8Like Alt in Haskell. This class is purely a Rel8 concept, and allows you to take a choice between two tables. See also `.For example, using c on O allows you to combine two tables and to return the first one that is a "just" MaybeTable.crel8#An associative binary operation on s.`abcc3PNone'(/<>?J=drel8 Selects a b means that a is a schema (i.e., a  of e s) for the  columns in b.erel8A Name is the name of a column, as it would be defined in a table's schema definition. You can construct names by using the OverloadedStrings extension and writing string literals. This is typically done when providing a  TableSchema value.deQNone%&/>?M frel8Construct a table in the e context containing the names of all columns. Nested column names will be combined with /. See also: g.grel8Construct a table in the e context containing the names of all columns. The supplied function can be used to transform column names.This function can be used to generically derive the columns for a  TableSchema. For example, myTableSchema :: TableSchema (MyTable Name) myTableSchema = TableSchema { columns = namesFromLabelsWith last } will construct a  TableSchema where each columns names exactly corresponds to the name of the Haskell field.fgNoneR`hrel8Corresponds to  date(now()).irel8Corresponds to calling the date function with a given time.jrel8Corresponds to x::timestamptz.krel8:Move forward a given number of days from a particular day.lrel8=Find the number of days between two days. Corresponds to the - operator.mrel82Subtract a given number of days from a particular . nrel8Corresponds to now().orel8Add a time interval to a point in time, yielding a new point in time.prel8$Find the duration between two times.qrel8Subtract a time interval from a point in time, yielding a new point in time.srel8An interval of one second.trel83Create a literal interval from a number of seconds.urel8An interval of one minute.vrel83Create a literal interval from a number of minutes.wrel8An interval of one hour.xrel81Create a literal interval from a number of hours.yrel8An interval of one day.zrel80Create a literal interval from a number of days.{rel8An interval of one week.|rel81Create a literal interval from a number of weeks.}rel8An interval of one month.~rel82Create a literal interval from a number of months.rel8An interval of one year.rel81Create a literal interval from a number of years.hijklmnopqrstuvwxyz{|}~hijklmnopqrstuvwxyz{|}~None/\b)rel8-The PostgreSQL string concatenation operator.rel8*Matches regular expression, case sensitiveCorresponds to the ~. operator.rel8,Matches regular expression, case insensitiveCorresponds to the ~* operator.rel81Does not match regular expression, case sensitiveCorresponds to the !~ operator.rel83Does not match regular expression, case insensitiveCorresponds to the !~* operator.rel8Corresponds to the  bit_length function.rel8Corresponds to the  char_length function.rel8Corresponds to the lower function.rel8Corresponds to the  octet_length function.rel8Corresponds to the upper function.rel8Corresponds to the ascii function.rel8Corresponds to the btrim function.rel8Corresponds to the chr function.rel8Corresponds to the convert function.rel8Corresponds to the  convert_from function.rel8Corresponds to the  convert_to function.rel8Corresponds to the decode function.rel8Corresponds to the encode function.rel8Corresponds to the initcap function.rel8Corresponds to the left function.rel8Corresponds to the length function.rel8Corresponds to the length function.rel8Corresponds to the lpad function.rel8Corresponds to the ltrim function.rel8Corresponds to the md5 function.rel8Corresponds to the pg_client_encoding() expression.rel8Corresponds to the  quote_ident function.rel8Corresponds to the  quote_literal function.rel8Corresponds to the quote_nullable function.rel8Corresponds to the regexp_replace function.rel8Corresponds to the regexp_split_to_array function.rel8Corresponds to the repeat function.rel8Corresponds to the replace function.rel8Corresponds to the reverse function.rel8Corresponds to the right function.rel8Corresponds to the rpad function.rel8Corresponds to the rtrim function.rel8Corresponds to the  split_part function.rel8Corresponds to the strpos function.rel8Corresponds to the substr function.rel8Corresponds to the  translate function.))62222RNone]rel8See ?https://www.postgresql.org/docs/current/functions-sequence.htmlSNone/_rel8!Sort a column in ascending order.rel8"Sort a column in descending order.rel8Transform an ordering so that null+ values appear first. This corresponds to  NULLS FIRST in SQL.rel8Transform an ordering so that null+ values appear first. This corresponds to  NULLS LAST in SQL.TNone'(/?ec rel8Corresponds to the SQL <+ operator. Note that this differs from SQL < as null3 will sort below any other value. For a version of < that exactly matches SQL, see .rel8Corresponds to the SQL <=+ operator. Note that this differs from SQL <= as null3 will sort below any other value. For a version of <= that exactly matches SQL, see .rel8Corresponds to the SQL >+ operator. Note that this differs from SQL > as null3 will sort below any other value. For a version of > that exactly matches SQL, see .rel8Corresponds to the SQL >=+ operator. Note that this differs from SQL > as null3 will sort below any other value. For a version of >= that exactly matches SQL, see .rel8Corresponds to the SQL < operator. Returns null if either arguments are null.rel8Corresponds to the SQL <= operator. Returns null if either arguments are null.rel8Corresponds to the SQL > operator. Returns null if either arguments are null.rel8Corresponds to the SQL >= operator. Returns null if either arguments are null.rel8Given two expressions, return the expression that sorts less than the other.Corresponds to the SQL least() function.rel8Given two expressions, return the expression that sorts greater than the other.Corresponds to the SQL  greatest() function. 44444444None?i_rel8Cast H types to I types. For example, this can be useful if you need to turn an  Expr Int32 into an  Expr Double.rel8Cast I types to G3 types. For example, his can be useful to convert  Expr Float to  Expr Double.rel8Round a G to a H, by rounding to the nearest larger integer.Corresponds to the  ceiling() function.rel8.Perform integral division. Corresponds to the div() function.rel8Corresponds to the mod() function.rel8Round a  DFractional to a H. by rounding to the nearest smaller integer. Corresponds to the floor() function.rel8Round a G to a H% by rounding to the nearest integer.Corresponds to the round() function.rel8Round a G to a H2 by rounding to the nearest integer towards zero.UNone&'(?nrel8&Compare two expressions for equality. This corresponds to the SQL IS NOT DISTINCT FROM operator, and will equate null values as true. This differs from = which would return null#. This operator matches Haskell's - operator. For an operator identical to SQL =, see .rel82Test if two expressions are different (not equal).This corresponds to the SQL IS DISTINCT FROM operator, and will return false when comparing two null$ values. This differs from ordinary = which would return null'. This operator is closer to Haskell's - operator. For an operator identical to SQL =, see .rel8Test if two expressions are equal. This operator is usually the best choice when forming join conditions, as PostgreSQL has a much harder time optimizing a join that has multiple  conditions.This corresponds to the SQL =+ operator, though it will always return a .rel8'Test if two expressions are different. This corresponds to the SQL <>+ operator, though it will always return a .rel8 Like the SQL IN8 operator, but implemented by folding over a list with  and 3.4444VNone#&+/9>?q3rel8 The class of s that can be compared for equality. Equality on tables is defined by equality of all columns all columns, so this class means "all columns in a  have an instance of ".rel8 Compare two s for equality. This corresponds to comparing all columns inside each table for equality, and combining all comparisons with AND.rel8 Test if two s are different. This corresponds to comparing all columns inside each table for inequality, and combining all comparisons with OR.44WNone#&/9>?trel8 The class of Tables that can be ordered. Ordering on tables is defined by their lexicographic ordering of all columns, so this class means "all columns in a Table have an instance of L".rel8 Test if one Table sorts before another. Corresponds to comparing all columns with .rel8 Test if one Table sorts before, or is equal to, another. Corresponds to comparing all columns with .rel8 Test if one Table sorts after another. Corresponds to comparing all columns with .rel8 Test if one Table sorts after another. Corresponds to comparing all columns with .rel8 Given two Table0s, return the table that sorts before the other.rel8 Given two Table/s, return the table that sorts after the other.4444XNone %/vhrel8 Construct an  for a Table by sorting all columns into ascending orders (any nullable columns will be sorted with  NULLS FIRST).rel8 Construct an  for a Table by sorting all columns into descending orders (any nullable columns will be sorted with  NULLS LAST).YNone%/>?xrel8A  NonEmptyTable) value contains one or more instances of a. You construct  NonEmptyTables with Z or  nonEmptyAgg.rel8%Project a single expression out of a .rel8 Construct a  NonEmptyTable& from a non-empty list of expressions.rel8 Construct a  in the e, context. This can be useful if you have a : that you are storing in a table and need to construct a  TableSchema.rel81The names of the columns of elements of the list.4[None/yrel8Nest a  list within a Rel8able.  HNonEmpty f a will produce a  a in the Expr context, and a  a in the  context.\None%/>?{rel8A  ListTable* value contains zero or more instances of a. You construct  ListTables with ] or ^.rel8%Project a single expression out of a .rel8 Construct a  ListTable from a list of expressions.rel8 Construct a  in the e, context. This can be useful if you have a : that you are storing in a table and need to construct a  TableSchema.rel81The names of the columns of elements of the list.4_None/|rel8Nest a list within a Rel8able.  HList f a will produce a  a in the Expr context, and a [a] in the  context.`Nonerel8Corresponds to the SQL DEFAULT expression.This > is unsafe for numerous reasons, and should be used with care: This  only makes sense in an INSERT or UPDATE statement.Rel8 is not able to verify that a particular column actually has a DEFAULT value. Trying to use  unsafeDefault6 where there is no default will cause a runtime crashDEFAULT values can not be transformed. For example, the innocuous Rel8 code unsafeDefault + 1# will crash, despite type checking.Given all these caveats, we suggest avoiding the use of default values where possible, instead being explicit. A common scenario where default values are used is with auto-incrementing identifier columns. In this case, we suggest using a instead.bNone%/>?rel8Aggregates a b means that the columns in a are all  s for the  columns in b.rel8 is a special context used by c. dNone #%&+/?rel8Transform a table by adding CAST to all columns. This is most useful for finalising a SELECT or RETURNING statement, guaranteed that the output matches what is encoded in each columns TypeInformation. eNoneSfNone%ugNone %'(Qrel8), h and i all support returning either the number of rows affected, or the actual rows modified.rel8#Return the number of rows affected.rel8 allows you to project out of the affected rows, which can be useful if you want to log exactly which rows were deleted, or to view a generated id (for example, if using a column with an autoincrementing counter via a).jNone #$%'(?(rel8The ON CONFLICT (...) DO UPDATE clause of an INSERT$ statement, also known as "upsert".When an existing row conflicts with a row proposed for insertion, ON CONFLICT DO UPDATE allows you to instead update this existing row. The conflicting row proposed for insertion is then "excluded", but its values can still be referenced from the SET and WHERE clauses of the UPDATE statement.Upsert in Postgres requires an explicit set of "conflict targets" @ the set of columns comprising the UNIQUE; index from conflicts with which we would like to recover.rel8The set of conflict targets, projected from the set of columns for the whole tablerel8 How to update each selected row.rel8 Which rows to select for update.rel8 represents the  ON CONFLICT clause of an INSERT statement. This specifies what ought to happen when one or more of the rows proposed for insertion conflict with an existing row in the table.rel8Abort the transaction if there are conflicting rows (Postgres' default)rel8 ON CONFLICT DO NOTHINGrel8 ON CONFLICT DO UPDATE kNone?$rel8Construct a query that returns the given input list of rows. This is like folding a list of  statements under l, but uses the SQL VALUES expression for efficiency.mNone?rel8Combine the results of two queries of the same type, collapsing duplicates.  union a b" is the same as the SQL statement  x UNION b.rel8Combine the results of two queries of the same type, retaining duplicates.  unionAll a b" is the same as the SQL statement  x UNION ALL b.rel8>Find the intersection of two queries, collapsing duplicates. intersect a b" is the same as the SQL statement  x INTERSECT b.rel8=Find the intersection of two queries, retaining duplicates. intersectAll a b" is the same as the SQL statement x INTERSECT ALL b.rel8:Find the difference of two queries, collapsing duplicates  except a b# is the same as the SQL statement  x EXCEPT b.rel8;Find the difference of two queries, retaining duplicates.  exceptAll a b# is the same as the SQL statement x EXCEPT ALL b.nNonerel8The Query monad allows you to compose a SELECT7 query. This monad has semantics similar to the list ([]) monad.rel8a =  [].rel8c = .oNone 567 Query b yields no rows.rel8Like without$, but with a custom membership test.None?rel8 takes a variable name, some expressions, and binds each of them to a new variable in the SQL. The a returned consists only of these variables. It's essentially a let" binding for Postgres expressions.None?xrel8 takes expressions that could potentially have side effects and "runs" them in the  monad. The returned expressions have no side effects and can safely be reused.None?rel8?Select each row from a table definition. This is equivalent to  FROM table.Nonevrel8=Select all distinct rows from a query, removing duplicates.  distinct q% is equivalent to the SQL statement SELECT DISTINCT q.rel8Select all distinct rows from a query, where rows are equivalent according to a projection. If multiple rows have the same projection, it is unspecified which row will be returned. If this matters, use .rel8Select all distinct rows from a query, where rows are equivalent according to a projection. If there are multiple rows with the same projection, the first row according to the specified  will be returned.None'(/>None %'(/?None/>4None>?rel8)The class of data types that support the  string_agg() aggregation function.None />?Qrel8-The class of database types that support the sum() aggregation function.None/?rel88Count the occurances of a single column. Corresponds to COUNT(a)rel8Count the number of distinct occurances of a single column. Corresponds to COUNT(DISTINCT a)rel8Corresponds to COUNT(*).rel85A count of the number of times a given expression is true.rel8Corresponds to bool_and.rel8Corresponds to bool_or.rel8Produce an aggregation for Expr a using the max function.rel8Produce an aggregation for Expr a using the max function.rel8Corresponds to sum. Note that in SQL, sum% is type changing - for example the sum of integer returns a bigint. Rel8 doesn't support this, and will add explicit cast back to the original input type. This can lead to overflows, and if you anticipate very large sums, you should upcast your input.rel89Take the sum of all expressions that satisfy a predicate.rel8Corresponds to  string_agg().rel8$Aggregate a value by grouping by it.rel8%Collect expressions values as a list.rel8/Collect expressions values as a non-empty list.None %&?rel8Group equal tables together. This works by aggregating each column in the given table with .rel8Aggregate rows into a single row containing an array of all aggregated rows. This can be used to associate multiple rows with a single row, without changing the over cardinality of the query. This allows you to essentially return a tree-like structure from queries.For example, if we have a table of orders and each orders contains multiple items, we could aggregate the table of orders, pairing each order with its items: ordersWithItems :: Query (Order Expr, ListTable Expr (Item Expr)) ordersWithItems = do order <- each orderSchema items  -aggregate $ listAgg <$. itemsFromOrder order return (order, items) rel8Like 6, but the result is guaranteed to be a non-empty list.None/:<= None/8:<None/8:<GNone%/5<>?y rel8 MaybeTable t is the table t, but as the result of an outer join. If the outer join fails to match any rows, this is essentialy Nothing7, and if the outer join does match rows, this is like Just. Unfortunately, SQL makes it impossible to distinguish whether or not an outer join matched any rows based generally on the row contents - if you were to join a row entirely of nulls, you can't distinguish if you matched an all null row, or if the match failed. For this reason  MaybeTable contains an extra field - a "nullTag" - to track whether or not the outer join produced any rows.rel8 Check if a  MaybeTable is absent of any row. Like =>.rel8 Check if a  MaybeTable contains a row. Like .rel8Perform case analysis on a . Like .rel8The null table. Like .rel8Lift any table into . Like . Note you can also use .rel8%Project a single expression out of a +. You can think of this operator like the 2 operator, but it also has the ability to return null.rel8-Lift an aggregating function to operate on a .  nothingTables and  justTables are grouped separately.rel8 Construct a  in the e, context. This can be useful if you have a : that you are storing in a table and need to construct a  TableSchema.rel8Has the same behavior as the Monad instance for Maybe.rel8Has the same behavior as the  Applicative instance for Maybe . See also: .rel83The name of the column to track whether a row is a  or .rel8Names of the columns in a. 4None%/5<>?rel8TheseTable a b0 is a Rel8 table that contains either the table a , the table b, or both tables a and b. You can construct  TheseTable s using ,  and .  TheseTable+s can be eliminated/pattern matched using . TheseTable( is operationally the same as Haskell's & type, but adapted to work with Rel8.rel8 Test if a  was constructed with .Corresponds to .rel8 Test if a  was constructed with .Corresponds to .rel8 Test if a  was constructed with .Corresponds to .rel8 Test if the a side of TheseTable a b is present.Corresponds to .rel8 Test if the b table of TheseTable a b is present.Corresponds to .rel8Attempt to project out the a table of a TheseTable a b.Corresponds to .rel8Attempt to project out the b table of a TheseTable a b.Corresponds to .rel8 Construct a  TheseTable. Corresponds to .rel8 Construct a  TheseTable. Corresponds to .rel8 Construct a  TheseTable. Corresponds to .rel8Pattern match on a . Corresponds to these.rel86Lift a pair of aggregating functions to operate on an .  thisTables,  thatTables and  thoseTables are grouped separately.rel8 Construct a  in the e, context. This can be useful if you have a : that you are storing in a table and need to construct a  TableSchema.rel84The name of the column to track the presence of the a table.rel84The name of the column to track the presence of the b table.rel8Names of the columns in the a table.rel8Names of the columns in the b table.None/rel8Nest an  value within a Rel8able.  HThese f a b will produce a  a b in the Expr context, and a  a b in the  context.None%'(rel8Convert a query that might return zero rows to a query that always returns at least one row.!To speak in more concrete terms,  is most useful to write  LEFT JOINs.rel8 Filter out /s, returning only the tables that are not-null.3This operation can be used to "undo" the effect of ), which operationally is like turning a  LEFT JOIN back into a full JOIN*. You can think of this as analogous to =.rel8Extend an optional query with another query. This is useful if you want to step through multiple  LEFT JOINs. Note that traverseMaybeTable takes a  a -> Query b function, which means you also have the ability to "expand" one row into multiple rows. If the  a -> Query b function returns no rows, then the resulting query will also have no rows. However, regardless of the given  a -> Query b function, if the input is  nothingTable", you will always get exactly one  nothingTable back.None?rel8/Apply an aggregation to all rows returned by a .rel8Count the number of rows returned by a query. Note that this is different from  countStar-, as even if the given query yields no rows,  countRows will return 0.None%'(?ʈrel8 Aggregate a  into a . If the supplied query returns 0 rows, this function will produce a , that returns one row containing the empty  ListTable. If the supplied Query does return rows, many& will return exactly one row, with a  ListTable collecting all returned rows.many is analogous to ] from Control.Applicative.rel8 Aggregate a  into a . If the supplied query returns 0 rows, this function will produce a - that is empty - that is, will produce zero  NonEmptyTables. If the supplied Query does return rows, some% will return exactly one row, with a  NonEmptyTable collecting all returned rows.some is analogous to Z from Control.Applicative.rel8 A version of # specialised to single expressions.rel8 A version of # specialised to single expressions.rel8 Expand a  into a :, where each row in the query is an element of the given  ListTable. catListTable is an inverse to .rel8 Expand a  into a :, where each row in the query is an element of the given  NonEmptyTable.catNonEmptyTable is an inverse to .rel81Expand an expression that contains a list into a ?, where each row in the query is an element of the given list.catList is an inverse to .rel8;Expand an expression that contains a non-empty list into a ?, where each row in the query is an element of the given list. catNonEmpty is an inverse to .None/}rel8Nest a  value within a Rel8able.  HMaybe f a will produce a  a in the Expr context, and a  a in the  context.None/8:<ˤNone%/5<>?krel8An EitherTable a b0 is a Rel8 table that contains either the table a or the table b. You can construct an  EitherTable using  and $, and eliminate/pattern match using .An  EitherTable( is operationally the same as Haskell's & type, but adapted to work with Rel8.rel8 Test if an  is a .rel8 Test if an  is a .rel8Pattern match/eliminate an  , by providing mappings from a  and .rel8Construct a left . Like .rel8Construct a right . Like .rel86Lift a pair of aggregating functions to operate on an .  leftTables and  rightTables are grouped separately.rel8 Construct a  in the e, context. This can be useful if you have a : that you are storing in a table and need to construct a  TableSchema.rel83The name of the column to track whether a row is a  or .rel8Names of the columns in the a table.rel8Names of the columns in the b table. None? rel8Filter s, keeping only  leftTables.rel8Filter s, keeping only  rightTables.rel8bitraverseEitherTable f g x will pass all  leftTable s through f and all  rightTable s through g). The results are then lifted back into  leftTable and  rightTable#, respectively. This is similar to  bitraverse for . For example,:{ select do: x <- values (map lit [ Left True, Right (42 :: Int32) ]) bitraverseEitherTable (\y -> values [y, not_ y]) (\y -> pure (y * 100)) x:} [ Left True , Left False , Right 4200]None/rel8Nest an  value within a Rel8able.  HEither f a b will produce a  a b in the Expr context, and a  a b in the  context.None'(?mrel8Corresponds to a FULL OUTER JOIN between two queries. None?Zrel8A  k a is like a  a', except that each row also has a key k in addition to the value a. )s can be composed monadically just like *s, but the resulting join is more like a  NATURAL JOIN$ (based on the common key column(s) k ) than the  CROSS JOIN given by .Another way to think of  k a is as analogous to Map k a in the same way  a is analogous to [a]'. However, there's nothing stopping a  from containing multiple rows with the same key, so technically Map k (NonEmpty a) is more accurate.s can be created from s with  and  and converted back to s with  and 6 (though note the caveats that come with the latter).rel8Any  of key-value pairs (k, a) can be a  k a.rel8 Convert a  k a back into a  of key-value pairs.Note that the result of a 1 is undefined (will always return zero rows) on s constructed with  or  . So while toQuery . fromQuery is always id, fromQuery . toQuery is not.)A safer, more predictable alternative to  is to use  with an explicit set of keys: ;do k <- keys a <- lookup k tabulation pure (k, a) 7Having said that, in practice, most legitimate uses of  will have a well-defined . It would be possible in theory to encode the necessary invariants at the type level using an indexed monad, but we would lose the ability to use do0-notation, which is the main benefit of having  as a monad in the first place.In particular,  t is well-defined for any  t defined as t = fromQuery _.  t is also well-defined for any  t defined as  t = t' >>= _ or  t = t' *> _ where  t' is well-defined. There are other valid permutations too. Generally, anything that uses / at some point, unless wrapped in a top-level  or , will have a well-defined .rel8A  a can be treated as a  k a where the given a% values exist at every possible key k.rel8Run a Kleisli arrow in the the  monad "through" a . Useful for ing a .  ((>=. 30) . userAge) ` ` usersById rel8 k t! returns the value(s) at the key k in the tabulation t.rel8- aggregates the values within each key of a . There is an implicit GROUP BY on all the key columns.rel8 ensures a  has at most one value for each key, i.e., it drops duplicates. In general it keeps only the "first" value it encounters for each key, but note that "first" is undefined unless you first call .rel8 orders the values of a  within their respective keys. This specifies a defined order for 6. It also defines the order of the lists produced by  and .rel87 returns a count of how many entries are in the given  at each key.The resulting  is "magic" in that the value 08 exists at every possible key that wasn't in the given .rel8 produces a "magic" " whereby each entry in the given  is wrapped in 2, and every other possible key contains a single .This is used to implement .rel8 aggregates each entry with a particular key into a single entry with all of the values contained in a . can be used to give this  a defined order.The resulting  is "magic" in that the value 'Rel8.listTable []'8 exists at every possible key that wasn't in the given .rel8 aggregates each entry with a particular key into a single entry with all of the values contained in a . can be used to give this  a defined order.rel8 produces a "magic"  which contains the value  at each key in the given , and the value  at every other possible key.rel8 produces a  where a single ()9 row exists for every key that was present in the given .This is used to implement .rel8 produces a  where a single ()> row exists at every possible key that absent from the given .This is used to implement .rel8 Performs a NATURAL FULL OUTER JOIN! based on the common key columns. Analogous to .rel8 Performs a NATURAL FULL OUTER JOIN! based on the common key columns. Analogous to .rel8 Performs a NATURAL LEFT OUTER JOIN! based on the common key columns. Analogous to ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just left right -> liftA2 (,) left (optional right). You can also use  do@-notation.rel8 Performs a NATURAL LEFT OUTER JOIN! based on the common key columns. Analogous to ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just f left right -> liftA2 f left (optional right). You can also use  do@-notation.rel8 Performs a NATURAL RIGHT OUTER JOIN! based on the common key columns. Analogous to ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just left right -> liftA2 (flip (,)) right (optional left). You can also use  do@-notation.rel8 Performs a NATURAL RIGHT OUTER JOIN! based on the common key columns. Analogous to ./Note that you can achieve the same effect with  and the  instance for , i.e., this is just f left right -> liftA2 (flip f) right (optional left). You can also use  do@-notation.rel8 Performs a NATURAL INNER JOIN! based on the common key columns. Analagous to .3Note that you can achieve the same effect with the  instance of , i.e., this is just  'liftA2 (,)'. You can also use do -notation.rel8 Performs a NATURAL INNER JOIN! based on the common key columns. Analagous to .3Note that you can achieve the same effect with the  instance of , i.e., this is just . You can also use do -notation.rel8 Performs a  https://en.wikipedia.org/wiki/Relational_algebra#Semijoin_%28%E2%8B%89%29%28%E2%8B%8A%29NATURAL SEMI JOIN" based on the common key columns.The result is a subset of the left tabulation where only entries which have a corresponding entry in the right tabulation are kept.0Note that you can achieve a similar effect with  and the  instance of , i.e., this is just #left right -> left <* present right. You can also use do -notation.rel8 Performs a  https://en.wikipedia.org/wiki/Relational_algebra#Antijoin_%28%E2%96%B7%29NATURAL ANTI JOIN" based on the common key columns.The result is a subset of the left tabulation where only entries which do not have a corresponding entry in the right tabulation are kept.0Note that you can achieve a similar effect with  and the  instance of , i.e., this is just "left right -> left <* absent right. You can also use do -notation.rel8If  k a is Map k (NonEmpty a), then (<>) is unionWith (liftA2 (<>)).rel8If  k a is Map k (NonEmpty a), then ( |:) is unionWith (<>).rel8 pure =  . purerel8If  k a is Map k (NonEmpty a), then ( .) is intersectionWith (liftA2 ( *))1None/>?None/>?LNone-./9>?grel8,This type class allows you to define custom s using higher-kinded data types. Higher-kinded data types are data types of the pattern: data MyType f = MyType { field1 :: Column f T1 OR HK1 f , field2 :: Column f T2 OR HK2 f , ... , fieldN :: Column f Tn OR HKn f } where Tn is any Haskell type, and HKn is any higher-kinded type.That is, higher-kinded data are records where all fields in the record are all either of the type  Column f T (for any T)), or are themselves higher-kinded data: Nested data Nested f = Nested { nested1 :: MyType f , nested2 :: MyType f } The Rel8able type class is used to give us a special mapping operation that lets us change the type parameter f.  Supplying Rel8able instancesThis type class should be derived generically for all table types in your project. To do this, enable the  DeriveAnyType and  DeriveGeneric language extensions: {-# LANGUAGE DeriveAnyClass, DeriveGeneric #-} data MyType f = MyType { fieldA :: Column f T } deriving ( GHC.Generics.Generic, Rel8able ) rel8 The kind of  types None+/>?None%&-/? None/>?hNone/None/>?None/>BNone%&'(+/?krel8 is used to associate composite type metadata with a Haskell type.rel83The names of all fields in the composite type that a maps to.rel8$The name of the composite type that a maps to.rel8A deriving-via helper type for column types that store a Haskell product type in a single Postgres column using a Postgres composite type.Note that this must map to a specific extant type in your database's schema (created with  CREATE TYPE). Use  to specify the name of this Postgres type and the names of the individual fields (for projecting with ).rel8 Collapse a " into a PostgreSQL composite type. values are represented in queries by having a column for each field in the corresponding Haskell type.  collapses these columns into a single column expression, by combining them into a PostgreSQL composite type.rel8Expand a composite type into a . is the inverse of .None/None#  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefgCDE@ABSTUQRNOPM VWXYIHGF !bc`a\]^ efg+)*?:_;<=>9104253678L,-./'%&#$("dKJZ[ nJ'&0&&&&&&&&+-/////./44577778888888888<<<<<<AAACBCBCDDDDEEEFFFFFFGGGHHIILLL6M:MMNNNNPPQQRaS S SSTTTTTTTTTTUUUUUVVVWWWWWWWXXYYYY[\\\\_`bb(dggg.jjjjjjjjjksmlmmmmmoqhqhqqqqqqr)r)rrrrrtuiuiuuuuuvvvwxyyz{{;~^Oc]Zc]Z*          *           !!!!!!!!"""""#########$$$$$$$$$$$%%%&&&&&&&,,,,--/111111123444444444455<=<<<<<@@@@@@@J'KLLPPQQVWY\bbbbbb(bbdddddddddddefggjnnnoooooooppqrru}=?O#rel8-1.2.2.0-Itc3dQP2aMwEwJUjfHdWdlRel8Rel8.Expr.TimeRel8.Expr.Text Rel8.Expr.Num Rel8.TabulateRel8.FCFRel8.Generic.MapRel8.Generic.RecordRel8.Kind.Algebra Rel8.OrderascdescData.Functor.Contravariant>$<Rel8.Query.OpaleyeRel8.Schema.DictRel8.Schema.KindRel8.Schema.HTable.ProductRel8.Schema.NullRel8.Schema.TableRel8.ColumnSchema ColumnSchemaRel8.Type.InformationDBTypeRel8.Type.Array Rel8.Type Rel8.Type.EqRel8.Schema.SpecRel8.Schema.Result Rel8.ColumnRel8.Schema.HTableRel8.Schema.HTable.MapTableRel8.Schema.HTable.NullifyRel8.Schema.HTable.LabelRel8.Generic.Table.Record Rel8.Generic.Construction.RecordRel8.Schema.HTable.Identity Rel8.TableExpr AggregateInsertRel8ableRel8.Table.TransposeRel8.Table.ColsRel8.Schema.Field ProjectionRel8.Table.ProjectionTableRel8.Schema.HTable.VectorizeRel8.Schema.HTable.NonEmptyRel8.Schema.HTable.ListRel8.Expr.OpaleyeRel8.Expr.SerializelitRel8.Expr.FunctionRel8.Expr.Bool Data.Boolboolwhere_Rel8.Expr.Null Data.Maybe isNothingisJustRel8.Expr.ArrayRel8.Type.JSONBEncoded JSONEncodedRel8.Type.JSONEncoded Rel8.Type.Num Rel8.Type.OrdRel8.Type.EnumRel8.Type.ReadShowRel8.Type.SemigroupRel8.Type.Monoid Rel8.ExprRel8.Table.UndefinedRel8.Table.SerializeRel8.Table.BoolRel8.Table.Alternative MaybeTableRel8.Schema.NameRel8.Table.NameRel8.Expr.SequenceRel8.Expr.Order Rel8.Expr.Ord Rel8.Expr.Eq Rel8.Table.EqRel8.Table.OrdRel8.Table.OrderRel8.Table.NonEmptysomeRel8.Column.NonEmptyRel8.Table.ListmanylistAggRel8.Column.ListRel8.Expr.DefaultnextvalRel8.Aggregate aggregateRel8.Table.OpaleyeRel8.Statement.WhereRel8.Statement.SetRel8.Statement.ReturningUpdateDeleteRel8.Statement.OnConflictRel8.Query.ValuesunionRel8.Query.Set Rel8.QueryRel8.Statement.SelectRel8.Statement.UsingRel8.Statement.UpdateRel8.Statement.InsertvaluesRel8.Statement.ViewRel8.Statement.DeleteRel8.Statement.SQLRel8.Query.SQLRel8.Query.OrderRel8.Query.LimitRel8.Query.IndexedRel8.Query.Filter Control.MonadguardRel8.Query.Null catMaybesRel8.Query.ExistsRel8.Query.RebindRel8.Query.EvaluateRel8.Query.EachRel8.Query.DistinctRel8.Kind.ContextRel8.Schema.Context.NullifyRel8.Table.NullifyRel8.Type.String Rel8.Type.SumRel8.Expr.AggregateRel8.Table.Aggregate Rel8.Type.TagRel8.Schema.HTable.TheseRel8.Schema.HTable.MaybeRel8.Table.MaybetraverseMaybeTableRel8.Table.TheseData.These.CombinatorsisThisisThatisThesehasHerehasThereRel8.Column.TheseRel8.Query.MaybeRel8.Query.AggregateRel8.Query.ListControl.ApplicativeRel8.Column.MaybeRel8.Schema.HTable.EitherRel8.Table.EitherRel8.Query.EitherRel8.Column.EitherRel8.Query.Thesefilter justTable nothingTabletruefalseData.Semialignalign alignWithrpadZip rpadZipWithlpadZip lpadZipWithzipzipWithRel8.Generic.Table.ADTRel8.Generic.TableRel8.Generic.Rel8ableRel8.Generic.Construction.ADTRel8.Generic.ConstructionRel8.Table.HKDRel8.Column.LiftRel8.Table.ADTRel8.Table.Rel8ableRel8.Type.CompositeRel8.Column.ADTOrderQuerySqlNullableNotNull TableSchemanameschemacolumnsTypeInformationencodedecodetypeNamemapTypeInformationparseTypeInformationtypeInformationDBEqResultColumnHTableColumnsContext FromExprs Transpose toColumns fromColumns fromResulttoResult TransposesField Biprojectable biproject Projectableproject ProjectingunsafeCastExpr unsafeLiterallitExprFunctionfunctionnullaryFunctionbinaryOperator&&.||.not_and_or_boolExprcaseExprcoalescenullifyisNull isNonNullmapNull liftOpNullnull JSONBEncodedfromJSONBEncodedfromJSONEncoded DBFloating DBFractional DBIntegralDBNumDBMinDBMaxDBOrdEnumableDBEnum enumValue enumTypeNameEnumReadShow fromReadShow DBSemigroup<>.DBMonoid memptyExpr SerializableToExprscase_nullableAlternativeTable emptyTableAltTable<|>:SelectsNamenamesFromLabelsnamesFromLabelsWithtodaytoDayfromDayaddDaysdiffDays subtractDaysnowaddTimediffTime subtractTime scaleIntervalsecondsecondsminuteminuteshourhoursdaydaysweekweeksmonthmonthsyearyears++.~.~*!~!~* bitLength charLengthlower octetLengthupperasciibtrimchrconvert convertFrom convertToinitcapleftlengthlengthEncodinglpadltrimmd5pgClientEncoding quoteIdent quoteLiteral quoteNullable regexpReplaceregexpSplitToArrayrepeatreplacereverserightrpadrtrim splitPartstrpossubstr translate nullsFirst nullsLast<.<=.>.>=.?>=? leastExpr greatestExpr fromIntegral realToFracceilingdivmodfloorroundtruncate==./=.==?/=?in_EqTable==:/=:OrdTable<:<=:>:>=:leastgreatestascTable descTable NonEmptyTable$+ nonEmptyTablenameNonEmptyTable HNonEmpty ListTable$* listTable nameListTableHList unsafeDefault Aggregates castTable ReturningNumberOfRowsAffectedUpsert$sel:index:Upsert$sel:set:Upsert$sel:updateWhere:Upsert OnConflictAbort DoNothingDoUpdateunionAll intersect intersectAllexcept exceptAllselect$sel:target:Update$sel:from:Update$sel:set:Update$sel:updateWhere:Update$sel:returning:Updateupdate$sel:into:Insert$sel:rows:Insert$sel:onConflict:Insert$sel:returning:Insertinsert createView$sel:from:Delete$sel:using:Delete$sel:deleteWhere:Delete$sel:returning:Deletedelete showDelete showInsert showUpdate showQueryorderBylimitoffsetindexedcatNullexistspresentabsentwithwithBywithout withoutByrebindevaluateeachdistinct distinctOn distinctOnByDBStringDBSumcount countDistinct countStar countWhereandormaxminsumsumWhere stringAgg listAggExprnonEmptyAggExprgroupBy nonEmptyAggisNothingTable isJustTable maybeTable$?aggregateMaybeTablenameMaybeTable TheseTable isThisTable isThatTable isThoseTable hasHereTable hasThereTable justHereTablejustThereTable thisTable thatTable thoseTable theseTableaggregateTheseTablenameTheseTableHTheseoptional catMaybeTable countRowsmanyExprsomeExpr catListTablecatNonEmptyTablecatList catNonEmptyHMaybe EitherTable isLeftTable isRightTable eitherTable leftTable rightTableaggregateEitherTablenameEitherTable keepLeftTablekeepRightTablebitraverseEitherTableHEitheralignBy keepHereTable loseHereTablekeepThereTableloseThereTable keepThisTable loseThisTable keepThatTable loseThatTablekeepThoseTableloseThoseTablebitraverseTheseTable Tabulation fromQuerytoQuery liftQuerythroughlookuporder leftAlign leftAlignWith rightAlignrightAlignWith similarity difference$fMonoidPredicate$fSemigroupPredicate$fContravariantPredicate$fMonoidTabulation$fSemigroupTabulation$fAlternativeTableTabulation$fAltTableTabulation$fMonadTabulation$fBindTabulation$fApplicativeTabulation$fApplyTabulation$fProjectableTabulation$fFunctorTabulation$fBifunctorTabulation$fBiprojectableTabulation KRel8able AggregateHKDNameHKDDeconstructHKD ConstructHKDBuildHKDHKDableHKDbuildHKD constructHKDdeconstructHKDnameHKD aggregateHKDLift AggregateADTNameADTDeconstructADT ConstructADTBuildADTADTableADTbuildADT constructADTdeconstructADTnameADT aggregateADT DBCompositecompositeFieldscompositeTypeName Compositecompose decomposeHADTIdEvalExpMapGMapRecordunrecord GRecordablegrecord gunrecordGRecord KnownAlgebra algebraSingSAlgebraSProductSSumAlgebraProductSumbaseGHC.Base<> toOrderExprs fromOpaleye toOpaleye mapOpaleyezipOpaleyeWithunsafePeekQueryDictHProduct HomonullableNullityNullNullify Unnullify GHC.MaybeNothingppTablearraylistTypeInformationnonEmptyTypeInformationencodeArrayElementextractArrayElement $fDBTypeValue $fDBTypeUUID$fDBTypeByteString$fDBTypeByteString0 $fDBTypeCI $fDBTypeCI0 $fDBTypeText $fDBTypeText0$fDBTypeCalendarDiffTime$fDBTypeTimeOfDay$fDBTypeLocalTime $fDBTypeDay$fDBTypeUTCTime$fDBTypeScientific$fDBTypeDouble $fDBTypeFloat $fDBTypeInt64 $fDBTypeInt32 $fDBTypeInt16 $fDBTypeChar $fDBTypeBoolSpeclabelsinfonullity specification nullifier unnullifier vectorizer unvectorizerTColumn htabulatehfieldhdictshspecs htraverseHFieldHConstrainTablehmap htabulateAMapSpecmapInfoHMapTableField Precompose precomposed HMapTable unHMapTablehprojectghc-prim GHC.TypesTypeHNullifyhguardhnullshnullify hunnullifyHLabelhlabelhrelabelhunlabel GSerialize gfromResult gtoResultGTablegtable gfromColumns gtoColumnsGContextGColumnsGConstructable gconstruct gdeconstruct Representable gtabulategindexGFields GConstruct GConstructor ToColumns FromColumns HIdentity unHIdentity Congruent TSerialize TTranspose TFromExprsTContextTColumnsTTableColsfromColstoColsfieldsapply HVectorize hvectorize hunvectorizehappendhemptyhcolumnHNonEmptyTable HListTablecastExpr scastExprsunsafeCastExpr fromPrimExpr toPrimExpr mapPrimExprzipPrimExprsWithtraversePrimExprtoColumn fromColumnslitExpr sparseValue nullableExprmaybefmapMaybeunsafeUnnullify nullableOfsnull unsafeMapNullunsafeLiftOpNullsappendsappend1semptyslistOf snonEmptyOflistOf nonEmptyOf$aeson-2.0.3.0-Ad6fk1RlxnEEsrfKUuj9HuData.Aeson.Types.ToJSONToJSONData.Aeson.Types.FromJSONFromJSONGHC.RealGHC.ReadReadGHC.ShowShowMonoid undefinedparse litHTableppColumn showLabels showNames time-1.9.3Data.Time.Calendar.DaysDay GHC.Classes==TrueBooleqTable<<=>>=ordTableNonEmpty Aggregator operationordering distinction zipOutputsunsafeMakeAggregate aggregator attributes binaryspec distinctspecexprsexprsWithNamestable tableFields unpackspec valuesspecviewppWhereppSetdecodeReturning ppReturning ppOnConflictreturn$fAlternativeTableQuery$fAltTableQuery OptimizedUnitEmptyppSelectppRows ppPrimSelectppFromppUsingppUpdateppInsertppIntoppDeleteStringinQuery Reifiable contextSingSContext SAggregateSExprSFieldSNameSResultNonNullifiabilityNFieldNResult NullifiablenullifiabilityNullifiability NAggregateNExprNNamenullifiableOrNotabsurdguardersguardsnullifyaggregateNullify groupByExpr slistAggExprsnonEmptyAggExprhgroupByTagMaybeTagIsJust EitherTagIsLeftIsRightisLeftisRight HTheseTablehhereTaghhere hthereTaghthere HMaybeTablehtaghjustJustpure$$fMonadMaybeTable$fApplicativeMaybeTabletagjust$these-1.1.1.1-H4LIXkxs4MmKTDtacNXMBs Data.TheseThesejustHere justThereThisThatherethere HEitherTablehlefthright Data.EitherEitherLeftRight ApplicativeliftA2GSerializeADT' GSerializeADTgfromResultADT gtoResultADT GColumnsADT' GColumnsADTGAlgebra GGColumns GGSerialize ggfromResult ggtoResultGRep GFromExprs serialize deserialize GMakeableADTgmakeADTGConstructableADTgdeconstructADT gconstructADT gbuildADT gunbuildADTRepresentableFields gftabulategfindex GBuildADTRepresentableConstructors gctabulategcindex GConstructors GConstructADTGConstructorADT GGAggregateGGName GGDeconstruct GGConstructGGConstructableGGBuild GGBuildableggbuild ggconstruct ggdeconstructggname ggaggregateHKDRepConstructableHKD BuildableHKDADTRepConstructableADT BuildableADT