!E^#      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                           !!!!!"""""""""""""""""" " " " " """""""""""""""""## #!#"###$#%#&#'#($)$*$+$,$-%.%/%0%1%2%3%4%5%6%7%8%9&:&;&<&=&>'?(@(A(B(C(D(E(F(G(H(I(J)K)L)M)N)O)P*Q*R*S*T*U*V*W*X*Y*Z+[+\+]+^+_+`+a+b+c+d+e,f,g,h-i.j.k.l.m.n.o.p.q.r.s.t.u.v.w.x.y.z.{.|.}.~............/////////////////////0000000001111111111112233333333333333333333333333333334445555666666677777777777777777777777777777777777777 7 7 7 7 7788888888888888888 8!8"8#8$8%8&8'8(8)8*8+8,8-8.8/808182838485868788898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O9P9Q:R:S:T:U:V:W:X:Y:Z:[:\:]:^:_:`:a:b:c:d;e;f;g;h;i;j;k;l;m;n;o;p;q;r;s;t;u;v;w;x<y<z<{<|<}<~<<<<<<<<<<=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBCCC D D D D DDDDDDDDDDDDDDDDDDD D!D"D#D$D%D&D'D(D)D*D+D,D-D.D/D0D1D2D3D4D5D6D7D8D9D:D;D<D=D>D?D@DADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQDRDSDTDUDVDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfDgDhDiDjDkDlDmDnDoDpDqDrDsDtDuDvDwDxDyCzC{C|C}C~CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFGGGGGGGGGGGGHHHHHHH I I I I IIIIIIIIIIIIIIIIIII I!I"IISafe68P-  Safe68PNone68;=CV(" project-m364After a union merge, the merge transaction is a result of union'ing relvars of the same name, introducing all uniquely-named relvars, union of constraints, union of atom functions, notifications, and types (unless the names and definitions collide, e.g. two types of the same name with different definitions)# project-m36Similar to a union merge, but, on conflict, prefer the unmerged section (relvar, function, etc.) from the branch named as the argument.$ project-m36Similar to the our/theirs merge strategy in git, the merge transaction's context is identical to that of the last transaction in the selected branch.& project-m364Dynamically create a tuple from attribute names and Ks.( project-m36Create attributes dynamically., project-m36The persistence strategy is a global database option which represents how to persist the database in the filesystem, if at all.- project-m36.no filesystem persistence/memory-only database. project-m36fsync off, not crash-safe/ project-m36xfull fsync to disk (flushes kernel and physical drive buffers to ensure that the transaction is on non-volatile storage)1 project-m36The 0 structure represents a set of attribute names or the same set of names but inverted in the context of a relational expression. For example, if a relational expression has attributes named "a", "b", and "c", the 3 of ("a","c") is ("b").7 project-m36OAn AtomFunction has a name, a type, and a function body to execute when called.C project-m360Used in tuple creation when creating a relation.E project-m36An atom expression represents an action to take when extending a relation or when statically defining a relation or a new tuple.L project-m36The disconnected transaction represents an in-progress workspace used by sessions before changes are committed. This is similar to git's "index". After a transaction is committed, it is "connected" in the transaction graph and can no longer be modified.Q project-m36sEvery set of modifications made to the database are atomically committed to the transaction graph as a transaction.R project-m36BEvery transaction has context-specific information attached to it.U project-m36bThe transaction graph is the global database's state which references every committed transaction.X project-m36A transaction graph's head name references the leaves of the transaction graph and can be used during session creation to indicate at which point in the graph commits should persist.Y project-m36Restriction predicates are boolean algebra components which, when composed, indicate whether or not a tuple should be retained during a restriction (filtering) operation.b project-m36Adding an atom function should be nominally a DatabaseExpr except for the fact that it cannot be performed purely. Thus, we create the DatabaseContextIOExpr.k project-m369Database context expressions modify the database context. project-m36Inclusion dependencies represent every possible database constraint. Constraints enforce specific, arbitrarily-complex rules to which the database context's relation variables must adhere unconditionally. project-m36The DatabaseContext is a snapshot of a database's evolving state and contains everything a database client can change over time. I spent some time thinking about whether the VirtualDatabaseContext/Schema and DatabaseContext data constructors should be the same constructor, but that would allow relation variables to be created in a "virtual" context which would appear to defeat the isomorphisms of the contexts. It should be possible to switch to an alternative schema to view the same equivalent information without information loss. However, allowing all contexts to reference another context while maintaining its own relation variables, new types, etc. could be interesting from a security perspective. For example, if a user creates a new relvar in a virtual context, then does it necessarily appear in all linked contexts? After deliberation, I think the relvar should appear in *all* linked contexts to retain the isomorphic properties, even when the isomorphism is for a subset of the context. This hints that the IsoMorphs should allow for "fall-through"; that is, when a relvar is not defined in the virtual context (for morphing), then the lookup should fall through to the underlying context. project-m36\Every transaction has one concrete database context and any number of isomorphic subschemas. project-m36HUsed to define a data constructor in a type constructor context such as Left a | Right b project-m36TFound in data constructors and type declarations: Left (Either Int Text) | Right Int project-m362Metadata definition for type constructors such as data Either a b. project-m36When the changeExpr returns a different result in the database context, then the reportExpr is triggered and sent asynchronously to all clients. project-m36IA relational expression represents query (read) operations on a database. project-m361Relation variables are identified by their names. project-m36>Used to represent the number of tuples in a relation.  project-m36/A tuple is a set of attributes mapped to their  values. project-m365The relation's tuple set is the body of the relation. project-m36" represent the head of a relation. project-m36;A relation's type is composed of attribute names and types. project-m36<The AttributeName is the name of an attribute in a relation. project-m364The AtomType uniquely identifies the type of a atom. project-m36~Database atoms are the smallest, undecomposable units of a tuple. Common examples are integers, text, or unique identity keys. project-m36uReturn True iff the atom type argument is relation-valued. If True, this indicates that the Atom contains a relation. project-m36*Equality function for a set of attributes. !$#"%&'(*)+,/.-016543278;:9<=>?@ABCDEJIHGFKLMNOPQRTSUVWXY`_^]\[Zabgfedchijk|{zyxwvutsronmlqp}~~}k|{zyxwvutsronmlqpjihbgfedcaY`_^]\[ZXWUVRTSQOPNLMKEJIHGFCDBA@?><=78;:91654320,/.-+(*)&'%!$#" NonepNonea project-m36Return the type of an .NoneNone=None None! None NoneV NoneC NoneNoneNone-None68m     m     None\ project-m36 Left-biased union of attributes.#;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]#;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]None]^^Safe_`abc`a_bcSafe dfeghijklm ighjklmdfeNoneopqopqSafe rsrsSafectuvwxyzwyxztuvNone-DF{ project-m36QConfigure a GHC environment/session which we will use for all script compilation.{|}~~}{|NoneǼ project-m36ERepresents a pointer into the database's transaction graph which the ks can then modify subsequently be committed to extend the transaction graph. The session contains staged (uncommitted) database changes as well as the means to switch between isomorphic schemas.  None" project-m36tCreate a new transaction which is identical to the original except that a new set of child transaction ids is added. project-m36Return the same transaction but referencing only the specific child transactions. This is useful when traversing a graph and returning a subgraph. This doesn't filter parent transactions because it assumes a head-to-root traversal. project-m36LRemove any child or parent transaction references not in the valud UUID set. project-m361Return the singular context which is not virtual. project-m362Returns all schemas including the concrete schema. project-m36UReturns all subschemas which are isomorphic or sub-isomorphic to the concrete schema.  NoneӸNoneNone  project-m36Used to determine if the atom arguments can be used with the data constructor. | This is the entry point for type-checking from RelationalExpression.hs project-m36FWalks the data and type constructors to extract the type variable map. project-m36SAttempt to match the data constructor argument to a type constructor type variable. project-m36aCreate an atom type iff all type variables are provided. Either Int Text -> ConstructedAtomType Either {Int , Text} project-m36 See notes at 6. The typeFromRelation must not include any wildcards. project-m36When creating a tuple, the data constructor may not complete the type constructor arguments, so the wildcard "TypeVar x" fills in the type constructor's argument. The tuple type must be resolved before it can be part of a relation, however. Example: Nothing does not specify the the argument in "Maybe a", so allow delayed resolution in the tuple before it is added to the relation. Note that this resolution could cause a type error. Hardly a Hindley-Milner system. project-m36VValidate that the type is provided with complete type variables for type constructors. project-m36ZDetermine if two types are equal or compatible (including special handling for TypeVar x). project-m363Determine if two typeVars are logically compatible.  None%  None None_ project-m36DAn optimized form of tuple update which updates vectors efficiently.!None}"None&'CV project-m36Difference takes two relations of the same type and returns a new relation which contains only tuples which appear in the first relation but not the second. project-m36=Generate a randomly-ordered list of tuples from the relation. project-m366Return a Relation describing the types in the mapping. project-m364Return a Relation describing the relation variables. project-m36Randomly resort the tuples. This is useful for emphasizing that two relations are equal even when they are printed to the console in different orders.'     '     #None ! "#$%&' ! "#$%&'$NoneU()*+,()*+,%None -0/.1234567 -0/.1234567&None9 project-m36Create a uniqueness constraint for the attribute names and relational expression. Note that constraint can span multiple relation variables.: project-m36 Create a kY which can be used to add a uniqueness constraint to attributes on one relation variable.; project-m36^Create a foreign key constraint from the first relation variable and attributes to the second.9:;<=9:;<='None>>(NoneD ?@ABCDEFGHI ?@ABCDEFGHI)NoneJKLMNOJKLMNO*NoneXPQRSTUVVSTUPQR+None\ project-m36wCreate a junk named atom function for use with searching for an already existing function in the AtomFunctions HashSet.] project-m363AtomFunction constructor for compiled-in functions.b project-m36 Create a bX which can be used to load a new atom function written in Haskell and loaded at runtime. Z[\]^_`abcd Z[\]^_`abcd,NoneKefgefg-Nonehh.None,7;<=FSTV q project-m36,All database values ("atoms") adhere to the q~ typeclass. This class is derivable allowing new datatypes to be easily marshaling between Haskell values and database values.u project-m36jCreates DatabaseContextExpr necessary to load the type constructor and data constructor into the database.ipomnkljqutsrvqutsripomnkljv/None 7;<=STV project-m36 Convert a  Traverseable of s to an p k. This is useful for converting, for example, a list of data values to a set of Insert expressions which can be used to add the values to the database. project-m36 Convert a  to a create a mH expression which can be used to create an empty relation variable. Use G to insert the actual tuple data. This function is typically used with JK. project-m36'Convert a list of key attributes and a  value to an r{ expression. This expression flushes the non-key attributes of the value to a tuple with the matching key attributes. project-m36'Convert a list of key attributes and a  value to a q] expression. This expression deletes tuples matching the key attributes from the value.0None  1None=  2None3None14None project-m36Hconvert an existing database context into its constituent expression. 5None#6None;=CV7NoneV# project-m36KUsed to start a fresh database state for a new database context expression.  project-m36AValidate that the type of the AtomExpr matches the expected type.  project-m363Look up the type's name and create a new attribute.+     +     8None68<  project-m36QOperators which manipulate a transaction graph and which transaction the current Session is based upon. project-m367Used for git-style head backtracking such as topic~3^2. project-m36bgit equivalent of ~: walk back n parents, arbitrarily choosing a parent when a choice must be made project-m36Ugit equivalent of ^: walk back one parent level to the nth arbitrarily-chosen parent  project-m36rgit equivalent of 'git-rev-list -n 1 --before X' find the first transaction which was created before the timestamp project-m368Record a lookup for a specific transaction in the graph.5 project-m36Execute the merge strategy against the transactions, returning a new transaction which can be then added to the transaction graph6 project-m36Returns the correct Transaction for the branch name in the graph and ensures that it is one of the two transaction arguments in the tuple.8 project-m36Search from a past graph point to all following heads for a specific transaction. If found, return the transaction path, otherwise a RelationalError.< project-m36After splicing out a subgraph, run it through this function to remove references to transactions which are not in the subgraph.A project-m36#Create a temporary branch for commit, merge the result to head, delete the temporary branch. This is useful to atomically commit a transaction, avoiding a TransactionIsNotHeadError but trading it for a potential MergeError. this is not a GraphOp because it combines multiple graph operations3 !"#$%&'()*+,-./0123456789:;<=>?@A3 !"#$%&'()*+,-./0123456789:;<=>?@A9None>OPOP:None@[ project-m36TThe incremental writer writes the transactions ids specified by the second argument.QRSTUVWXYZ[\]^_`abcQRSTUVWXYZ[\]^_`abc;None;=Dj project-m36The TransGraphRelationalExpression is equivalent to a relational expression except that relation variables can reference points in the transaction graph (at previous points in time).defghijklmnopqjihgfedklmnopq<NoneEPxyz{|}~xyz{|}~=NoneH  project-m36[Returns the notifications which should be triggered based on the transition from the first  to the second .>None68]X2 project-m36Return an error if the schema is not isomorphic to the base database context. A schema is fully isomorphic iff all relvars in the base context are in the "out" relvars, but only once. TODO: add relvar must appear exactly once constraint project-m36Relation variables names represented in the virtual schema space. Useful for determining if a relvar name is valid in the schema. project-m36LCheck that all mentioned relvars are actually present in the current schema. project-m36~If the database context expression adds or removes a relvar, we need to update the isomorphs to create a passthrough Isomorph. project-m36IMorph a relational expression in one schema to another isomorphic schema. project-m36Apply the isomorphism transformations to the relational expression to convert the relational expression from operating on one schema to a disparate, isomorphic schema. project-m36jCreate inclusion dependencies mainly for IsoRestrict because the predicate should hold in the base schema.?NoneYP@SafeYANoneZBNone68\ project-m36LA Relation can be converted to a DataFrame for sorting, limits, and offsets.''DNone68`? project-m36The initial login message. The argument should be the process id of the initiating client. This ProcessId will receive notification callbacks.8      !"#$%&'()*+,-./0123456789:;<=>?@8?@=>;<9:78563412/0-.+,)*'(%&#$!"      CNone68V.(y project-m364There are several reasons why a connection can fail.# project-m36The ~d represents either local or remote access to a database. All operations flow through the connection. project-m36"When a notification is fired, the ; is evaluated in the commit's pre-change context while the d is evaluated in the post-change context and they are returned along with the original notification.$ project-m36IUsed for callbacks from the server when monitored changes have been made. project-m36 Construct a  to describe how to make the ~a. The database can be run within the current process or running remotely via distributed-process. project-m36The type for notifications callbacks in the client. When a registered notification fires due to a changed relational expression evaluation, the server propagates the notifications to the clients in the form of the callback. project-m366The empty notification callback ignores all callbacks. project-m36 Create a D for use in connecting to a remote server using distributed-process. project-m36>Use this for connecting to remote servers on the default port. project-m36IUse this for connecting to remote servers with the default database name. project-m36EUse this for connecting to remote servers with the default head name. project-m36Create a connection configuration which connects to the localhost on the default server port and default server database name. The configured notification callback is set to ignore all events. project-m36 To create a ~) to a remote or local database, create a  and call . project-m36GCreate a new session at the transaction id and return the session's Id. project-m36Call m with a transaction graph's head's name to create a new session pinned to that head. This function returns a [ which can be used in other function calls to reference the point in the transaction graph. project-m36tUsed internally for server connections to keep track of remote nodes for the purpose of sending notifications later. project-m36ODiscards a session, eliminating any uncommitted changes present in the session. project-m36J cleans up the database access connection and closes any relevant sockets. project-m36=Returns the name of the currently selected isomorphic schema. project-m36&Switch to the named isomorphic schema. project-m36Execute a relational expression in the context of the session and connection. Relational expressions are queries and therefore cannot alter the database. project-m36Execute a database context expression in the context of the session and connection. Database expressions modify the current session's disconnected transaction but cannot modify the transaction graph. project-m36Similar to a git rebase, k atomically creates a temporary branch and merges it to the latest commit of the branch referred to by the X> and commits the merge. This is useful to reduce incidents of s but at the risk of merge errors (thus making it similar to rebasing). Alternatively, as an optimization, if a simple commit is possible (meaning that the head has not changed), then a fast-forward commit takes place instead. project-m36[Execute a database context IO-monad-based expression for the given session and connection. bs modify the DatabaseContext but cannot be purely implemented. this is almost completely identical to executeDatabaseContextExpr above project-m36Execute a transaction graph expression in the context of the session and connection. Transaction graph operators modify the transaction graph state. project-m36dA trans-graph expression is a relational query executed against the entirety of a transaction graph. project-m36ESchema expressions manipulate the isomorphic schemas for the current . project-m36After modifying a ,  the transaction to the transaction graph at the head which the session is referencing. This will also trigger checks for any notifications which need to be propagated. project-m36(Discard any changes made in the current  and . This resets the disconnected transaction to reference the original database context of the parent transaction and is a very cheap operation.% project-m36oWrite the transaction graph to disk. This function can be used to incrementally write new transactions to disk. project-m36Return a relation whose type would match that of the relational expression if it were executed. This is useful for checking types and validating a relational expression's types. project-m36 Return a MapL of the database's constraints at the context of the session and connection. project-m36Return an optimized database expression which is logically equivalent to the input database expression. This function can be used to determine which expression will actually be evaluated. project-m36Return a relation which represents the current state of the global transaction graph. The attributes are * current- boolean attribute representing whether or not the current session references this transaction * head- text attribute which is a non-empty X iff the transaction references a head. * id- id attribute of the transaction * parents- a relation-valued attribute which contains a relation of transaction ids which are parent transaction to the transaction project-m36EReturns the names and types of the relation variables in the current . project-m36AReturns the names and types of the atom functions in the current . project-m36hReturns the transaction id for the connection's disconnected transaction committed parent transaction.  project-m36YReturns Just the name of the head of the current disconnected transaction or Nothing.  project-m36.Returns a listing of all available atom types. project-m36wRuns an IO monad, commits the result when the monad returns no errors, otherwise, rolls back the changes and the error.4!"#$&'()*+,-./123456EFGHIJXYZ[\]^_`bcdefgkpqlmnorstuvwxyz{|     >9:;bqrstu jyz{|}~4~yz{|}X,-./kpqlmnorstuvwxyz{|bcdefg!"#$>j +9:;b()*123456     qrstu&'EFGHIJYZ[\]^_`ENone project-m36cReturns a relation which lists the names of relvars in the current session as well as its types. FNone  GNone˺  HNoneVҹ project-m36TA notification callback which logs the notification to stderr and does nothing else. project-m36LA synchronous function to start the project-m36 daemon given an appropriate . Note that this function only returns if the server exits. Returns False if the daemon exited due to an error. If the second argument is not Nothing, the port is put after the server is ready to service the port.INoneK   project-m36AA union of connection and other errors that can be returned from . project-m36A simple alternative to connectProjectM36* which includes simple session management. project-m36Same as  but always connects to the master branch. project-m36Closes the database connection. project-m36Runs a Db monad which may include some database updates. If an exception or error occurs, the transaction is rolled back. Otherwise, the transaction is committed to the head of the current branch. project-m36Same as 1 except that the merge strategy can be specified. project-m36 Execute a k in the DB monad. Database context expressions manipulate the state of the database. In case of an error, the transaction is terminated and the connection's session is rolled back. project-m36Run a  query in the DB\ monad. Relational expressions perform read-only queries against the current database state. project-m36Run a kd update expression. If there is an error, just return it without cancelling the current transaction. project-m36Run a [ query expression. If there is an error, just return it without cancelling the transaction. project-m36tUnconditionally roll back the current transaction and throw an exception to terminate the execution of the Db monad. project-m36>Cancel a transaction and carry some error information with it. project-m36 Converts the & result from a  6 action into an immediate cancel in the case of error.,-./kpqlmnorstuvwxyz{|     qrs               qrs,-./kpqlmnorstuvwxyz{|'LMNOPQRSTUVWXYZ[\]^_`abccdefgghijklmnopoqrstuvwxyzy{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    -            !"#$%&'()*+,-./0123456789:;<=>?@AMBCDEFGHIJK\LMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&t-                           !!!!!"""""""" "!"""#"$"%"&"'""(")"p"*"+","-"."/"0"1"2"3"4"5"6"7"8"9":";"<"=#>#?#@#A#B#C#D#E#F#G$H$I$J$K$L%M%N%O%P%Q%R%S%T%U%V%W%X&Y&Z&[&\&]'^(_(`(a(b(c(d(e(f(g(h(i)j)k)l)m)n)o*p*p*q*r*r*s*t*u*v*w+x+y+z+{+|+}+~++++,,,-................................./////////////////////0000000001111111111112233333333333333333333333333333334445555666666677777777777 7 77 7 7 7777777777777777777 7!7"7#7$7%7&7'7(7)8*8+8,8-8.8/80818283848586878889898:8;8<8=8>8?8@8A8B8C8D8E8F8G8H8I8J8K8L8M8N8O8P8Q8R8S8T8U8V8W8X8Y8Z8[8\8]8^8_8`8a8b8c8d8e8f8g8h9i9j:k:l:m:n:o:p:q:r:s:t:u:v:w:x:y:z:{:|:};~;;;;;;;;;;;;;;K;G;H;M;J;I<<<<<<<<<<<<<<<<=>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>??@@@@@AAAAAAAAAAAAAAAAAAAAAAAAAAAAABBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBnBjBBBBBBBBBBBBBB B B B B BBDDDDDDDDDDDDDDDDDDDDDDDDD D D!D!D"D"D#D#D$D$D%D%D&D&D'D'D(D(D)D)D*D*D+D+D,D,D-D-D.D.D/D/D0D1D2D3D4D5D6D7D8D9D:D;D<D=D>D?D@DADBDCDDDEDFDGDHDIDJDKDLDMDNDODPDQDRDSDTDUDVDWDXDYDZD[D\D]D^D_D`DaDbDcDdDeDfDgChCiCjCkClCmCnCoCpCpCqCrCsCtCuCvCwCwCxCxCyCzC{C|C}C~CCCCCCCCCCCCCCCCC[CCCCCCCCCCCC:CCiCCCCCCCCCCCCCCCCCCCCCCCCCCEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEFFFFFFFFFFFFGGGGGGGGGGGGHHHHHHHIIIIIIIIIIIIIIIIIIIIIIIIIICCCproject-m36-0.7-inplaceProjectM36.AtomFunctionError'ProjectM36.DatabaseContextFunctionErrorProjectM36.BaseProjectM36.DataTypes.SortingProjectM36.DataTypes.PrimitiveProjectM36.DataTypes.MaybeProjectM36.DataTypes.List!ProjectM36.DataTypes.NonEmptyListProjectM36.DataConstructorDefProjectM36.AttributeNamesProjectM36.AtomFunctionBodyProjectM36.DataTypes.DayProjectM36.DataTypes.DateTimeProjectM36.DataTypes.ByteString"ProjectM36.DisconnectedTransactionProjectM36.ErrorProjectM36.AttributeProjectM36.AttributeExprProjectM36.FSTypeProjectM36.FileLockProjectM36.FunctionalDependencyProjectM36.MiscUtilsProjectM36.PersistProjectM36.ScriptSessionProjectM36.SessionProjectM36.TransactionProjectM36.TypeConstructorProjectM36.TypeConstructorDefProjectM36.AtomTypeProjectM36.DataTypes.IntervalProjectM36.AtomProjectM36.TupleProjectM36.TupleSetProjectM36.Relation!ProjectM36.TransactionGraph.MergeProjectM36.SessionsProjectM36.Relation.Parse.CSVProjectM36.KeyProjectM36.InclusionDependency"ProjectM36.DatabaseContextFunctionProjectM36.Relation.Show.HTMLProjectM36.Relation.Show.CSVProjectM36.AtomFunctionProjectM36.DataTypes.EitherProjectM36.DataTypes.BasicProjectM36.AtomableProjectM36.Tupleable"ProjectM36.AtomFunctions.Primitive ProjectM36.Relation.Show.GnuplotProjectM36.AtomFunctions.BasicProjectM36.Transaction.PersistProjectM36.DatabaseContextProjectM36.DateExamplesProjectM36.ArbitraryProjectM36.RelationalExpressionProjectM36.TransactionGraph ProjectM36.TransactionGraph.Show#ProjectM36.TransactionGraph.Persist)ProjectM36.TransGraphRelationalExpressionProjectM36.StaticOptimizerProjectM36.NotificationsProjectM36.IsomorphicSchema'ProjectM36.DatabaseContextFunctionUtilsProjectM36.WCWidthProjectM36.Relation.Show.TermProjectM36.DataFrameProjectM36.Client!ProjectM36.Server.RemoteCallTypesProjectM36.Server.EntryPointsProjectM36.Server.ConfigProjectM36.Server.ParseArgsProjectM36.ServerProjectM36.Client.SimpleDataProxyAtomFunctionErrorAtomFunctionUserErrorAtomFunctionTypeMismatchErrorInvalidIntervalOrderingErrorInvalidIntervalBoundariesErrorInvalidIntBoundErrorAtomFunctionEmptyRelationError#AtomTypeDoesNotSupportOrderingError#AtomTypeDoesNotSupportIntervalErrorAtomFunctionBytesDecodingError$fGenericAtomFunctionError$fEqAtomFunctionError$fShowAtomFunctionError$fBinaryAtomFunctionError$fNFDataAtomFunctionErrorDatabaseContextFunctionError DatabaseContextFunctionUserError%$fGenericDatabaseContextFunctionError $fEqDatabaseContextFunctionError"$fShowDatabaseContextFunctionError$$fBinaryDatabaseContextFunctionError$$fNFDataDatabaseContextFunctionErrorDatabaseContextFunctionsDatabaseContextFunction dbcFuncName dbcFuncType dbcFuncBodyDatabaseContextFunctionBodyDatabaseContextFunctionBodyType!DatabaseContextFunctionBodyScriptDatabaseContextFunctionName MergeStrategyUnionMergeStrategyUnionPreferMergeStrategySelectedBranchMergeStrategy TupleExpr TupleExprBaseAttributeExprBaseAttributeAndTypeNameExprNakedAttributeExpr AttributeExprPersistenceStrategy NoPersistenceMinimalPersistenceCrashSafePersistenceAttributeNamesAttributeNamesBaseInvertedAttributeNamesUnionAttributeNamesIntersectAttributeNamesRelationalExprAttributeNames AtomFunction atomFuncName atomFuncType atomFuncBodyAtomFunctionBodyAtomFunctionBodyTypeAtomFunctionBodyScriptAtomFunctionName AtomFunctionsExtendTupleExprExtendTupleExprBaseAttributeExtendTupleExpr AtomExprBaseAttributeAtomExpr NakedAtomExprFunctionAtomExprRelationAtomExprConstructedAtomExprAtomExprDisconnectedTransaction DirtyFlag Transaction TransactionIdTransactionInfoMergeTransactionInfoTransactionGraphTransactionHeadsHeadNameRestrictionPredicateExprBase TruePredicate AndPredicate OrPredicate NotPredicateRelationalExprPredicateAtomExprPredicateAttributeEqualityPredicateRestrictionPredicateExprDatabaseContextIOExprAddAtomFunctionLoadAtomFunctionsAddDatabaseContextFunctionLoadDatabaseContextFunctionsCreateArbitraryRelationRangeObjFunctionName ObjModuleNameDatabaseContextExpr NoOperationDefineUndefineAssignInsertDeleteUpdateAddInclusionDependencyRemoveInclusionDependencyAddNotificationRemoveNotificationAddTypeConstructorRemoveTypeConstructorRemoveAtomFunctionRemoveDatabaseContextFunctionExecuteDatabaseContextFunction MultipleExprDatabaseContextExprNameAttributeNameAtomExprMapInclusionDependency IncDepNameDatabaseContextinclusionDependenciesrelationVariables atomFunctions dbcFunctions notificationstypeConstructorMappingSchemaIsomorphsSchemaIsomorph IsoRestrict IsoRenameIsoUnionSchemaSchemas Subschemas SchemaNameRelationVariablesInclusionDependenciesDataConstructorDefArg$DataConstructorDefTypeConstructorArg DataConstructorDefTypeVarNameArgDataConstructorDefsDataConstructorDef AtomTypeNameDataConstructorNameTypeConstructorArgNameTypeConstructorNameTypeConstructorMappingTypeConstructorBaseADTypeConstructorPrimitiveTypeConstructorRelationAtomTypeConstructor TypeVariableTypeConstructorTypeConstructorDefADTypeConstructorDefPrimitiveTypeConstructorDef TypeVarName Notification changeExpr reportOldExpr reportNewExpr NotificationsNotificationNameRelationalExprBaseMakeRelationFromExprsMakeStaticRelationExistingRelationRelationVariableProjectUnionJoinRename DifferenceGroupUngroupRestrictEquals NotEqualsExtendWithRelationalExpr RelVarNameRelationCardinality CountableFiniteRelation RelationTupleRelationTupleSetasList Attributes Attribute AttributeName TypeVarMapAtomType IntAtomTypeIntegerAtomTypeDoubleAtomType TextAtomType DayAtomTypeDateTimeAtomTypeByteStringAtomType BoolAtomTypeRelationAtomTypeConstructedAtomTypeTypeVariableTypeAtom IntegerAtomIntAtom DoubleAtomTextAtomDayAtom DateTimeAtomByteStringAtomBoolAtom RelationAtomConstructedAtom StringTypeisRelationAtomTypeattributesEqualsortedAttributesIndicestransactionsForGraphtransactionHeadsForGraph transactionIdtransactionInfo attrTypeVarstypeVarsattrExprTypeVars atomTypeVars $fBinaryDay$fBinaryUTCTime$fHashableAttribute $fHashableMap $fOrdAtomType$fBinaryRelation$fHashableRelation$fNFDataRelation $fEqRelation$fNFDataRelationTuple$fEqRelationTuple$fBinaryRelationTuple$fHashableRelationTuple$fNFDataRelationTupleSet$fEqRelationTupleSet$fReadRelation$fHashableAtom$fBinaryTransactionInfo$fShowAtomFunctionBody$fNFDataAtomFunctionBody$fShowAtomFunction$fEqAtomFunction$fHashableAtomFunction$fBinaryAttributeNamesBase$fBinaryExtendTupleExprBase$fBinaryAtomExprBase$$fBinaryRestrictionPredicateExprBase$fBinaryRelationalExprBase$fBinaryInclusionDependency$fBinaryTupleExprBase$fEqDatabaseContextFunction!$fHashableDatabaseContextFunction#$fNFDataDatabaseContextFunctionBody$fOrdTransaction$fEqTransaction$fEqRelationCardinality$fShowRelationCardinality$fGenericRelationCardinality$fOrdRelationCardinality $fEqAtomType$fNFDataAtomType$fGenericAtomType$fBinaryAtomType$fShowAtomType $fEqAttribute$fShowAttribute$fGenericAttribute$fNFDataAttribute$fBinaryAttribute$fShowTypeConstructorDef$fGenericTypeConstructorDef$fBinaryTypeConstructorDef$fEqTypeConstructorDef$fNFDataTypeConstructorDef$fEqAtom $fShowAtom $fBinaryAtom $fNFDataAtom $fGenericAtom$fShowRelation$fGenericRelation$fHashableRelationTupleSet$fShowRelationTupleSet$fGenericRelationTupleSet$fBinaryRelationTupleSet$fShowRelationTuple$fGenericRelationTuple$fShowTransactionInfo$fGenericTransactionInfo$fGenericAtomFunction$fNFDataAtomFunction$fShowPersistenceStrategy$fReadPersistenceStrategy$fEqAttributeExprBase$fShowAttributeExprBase$fGenericAttributeExprBase$fBinaryAttributeExprBase$fNFDataAttributeExprBase$fShowTypeConstructorBase$fGenericTypeConstructorBase$fBinaryTypeConstructorBase$fEqTypeConstructorBase$fNFDataTypeConstructorBase$fShowDataConstructorDefArg$fGenericDataConstructorDefArg$fBinaryDataConstructorDefArg$fEqDataConstructorDefArg$fNFDataDataConstructorDefArg$fEqDataConstructorDef$fShowDataConstructorDef$fBinaryDataConstructorDef$fGenericDataConstructorDef$fNFDataDataConstructorDef$fEqTupleExprBase$fShowTupleExprBase$fGenericTupleExprBase$fNFDataTupleExprBase$fEqAtomExprBase$fShowAtomExprBase$fGenericAtomExprBase$fNFDataAtomExprBase$fShowRelationalExprBase$fEqRelationalExprBase$fGenericRelationalExprBase$fNFDataRelationalExprBase$fEqAttributeNamesBase$fShowAttributeNamesBase$fGenericAttributeNamesBase$fNFDataAttributeNamesBase$fShowExtendTupleExprBase$fEqExtendTupleExprBase$fGenericExtendTupleExprBase$fNFDataExtendTupleExprBase"$fShowRestrictionPredicateExprBase $fEqRestrictionPredicateExprBase%$fGenericRestrictionPredicateExprBase$$fNFDataRestrictionPredicateExprBase$fGenericSchemaIsomorph$fBinarySchemaIsomorph$fShowSchemaIsomorph$fGenericSchema$fBinarySchema$fShowInclusionDependency$fEqInclusionDependency$fGenericInclusionDependency$fNFDataInclusionDependency$fShowNotification$fEqNotification$fBinaryNotification$fGenericNotification$fNFDataNotification$fEqMergeStrategy$fShowMergeStrategy$fBinaryMergeStrategy$fGenericMergeStrategy$fNFDataMergeStrategy$fShowDatabaseContextExpr$fEqDatabaseContextExpr$fBinaryDatabaseContextExpr$fGenericDatabaseContextExpr$fShowDatabaseContextIOExpr$fEqDatabaseContextIOExpr$fGenericDatabaseContextIOExpr$fBinaryDatabaseContextIOExpr $fGenericDatabaseContextFunction$fNFDataDatabaseContextFunction$fNFDataDatabaseContext$fGenericDatabaseContext compareAtomsisSortableAtomTypeprimitiveTypeConstructorMappingintTypeConstructordoubleTypeConstructortextTypeConstructordayTypeConstructordateTimeTypeConstructoratomTypeForAtom maybeAtomTypemaybeTypeConstructorMappingmaybeAtomFunctions listAtomTypelistTypeConstructorMapping listLength listMaybeHeadlistAtomFunctionslistConsnonEmptyListAtomType"nonEmptyListTypeConstructorMappingnonEmptyListLengthnonEmptyListHeadnonEmptyListAtomFunctionsemptyDataConstructornamefieldstypeVarsInDefArgemptyallcompiledAtomFunctionBodydayAtomFunctionsdateTimeAtomFunctionsbytestringAtomFunctionsconcreteDatabaseContextschemasparentId ServerErrorRequestTimeoutErrorProcessDiedError SchemaErrorRelVarReferencesMissingRelVarInReferencedMoreThanOnceRelVarOutReferencedMoreThanOnceScriptCompilationErrorTypeCheckCompilationErrorSyntaxErrorCompilationErrorScriptCompilationDisabledErrorOtherScriptCompilationError MergeErrorSelectedHeadMismatchMergeErrorPreferredHeadMissingMergeError$StrategyViolatesConstraintMergeErrorInvalidMergeStrategyError)DisconnectedTransactionNotAMergeHeadError#StrategyViolatesComponentMergeError*StrategyViolatesRelationVariableMergeError)StrategyViolatesTypeConstructorMergeErrorPersistenceErrorInvalidDirectoryErrorMissingTransactionErrorWrongDatabaseFormatVersionErrorRelationalErrorNoSuchAttributeNamesError TupleAttributeCountMismatchErrorEmptyAttributesErrorDuplicateAttributeNamesErrorTupleAttributeTypeMismatchErrorAttributeCountMismatchErrorAttributeNamesMismatchErrorAttributeNameInUseError!AttributeIsNotRelationValuedErrorCouldNotInferAttributesRelVarNotDefinedErrorRelVarAlreadyDefinedErrorRelationTypeMismatchErrorInclusionDependencyCheckError!InclusionDependencyNameInUseError$InclusionDependencyNameNotInUseError ParseErrorPredicateExpressionError NoCommonTransactionAncestorErrorNoSuchTransactionErrorRootTransactionTraversalError$HeadNameSwitchingHeadProhibitedErrorNoSuchHeadNameErrorUnknownHeadError%NewTransactionMayNotHaveChildrenErrorParentCountTraversalError NewTransactionMissingParentErrorTransactionIsNotAHeadErrorTransactionGraphCycleErrorSessionIdInUseErrorNoSuchSessionErrorFailedToFindTransactionErrorTransactionIdInUseErrorNoSuchFunctionErrorNoSuchTypeConstructorNameTypeConstructorAtomTypeMismatchAtomTypeMismatchErrorTypeConstructorNameMismatch*AtomTypeTypeConstructorReconciliationErrorDataConstructorNameInUseError)DataConstructorUsesUndeclaredTypeVariableTypeConstructorTypeVarsMismatchTypeConstructorTypeVarMissing$TypeConstructorTypeVarsTypesMismatchDataConstructorTypeVarsMismatch'AtomFunctionTypeVariableResolutionError AtomFunctionTypeVariableMismatchAtomTypeNameInUseError/IncompletelyDefinedAtomTypeWithConstructorErrorAtomTypeNameNotInUseErrorAttributeNotSortableErrorFunctionNameInUseErrorFunctionNameNotInUseErrorEmptyCommitError"FunctionArgumentCountMismatchError)ConstructedAtomArgumentCountMismatchErrorNoSuchDataConstructorErrorNoSuchTypeConstructorErrorInvalidAtomTypeNameAtomTypeNotSupportedAtomOperatorNotSupportedEmptyTuplesErrorAtomTypeCountErrorAtomFunctionTypeErrorPrecompiledFunctionRemoveError)RelationValuedAttributesNotSupportedErrorNotificationNameInUseErrorNotificationNameNotInUseError ImportError ExportErrorUnhandledExceptionErrorMergeTransactionError ScriptErrorLoadFunctionErrorDatabaseLoadErrorSubschemaNameInUseErrorSubschemaNameNotInUseErrorSchemaCreationErrorImproperDatabaseStateErrorMultipleErrors someErrors$fNFDataMergeError!$fExceptionScriptCompilationError$fShowPersistenceError$fEqPersistenceError$fGenericPersistenceError$fBinaryPersistenceError$fNFDataPersistenceError$fShowMergeError$fEqMergeError$fGenericMergeError$fBinaryMergeError$fShowScriptCompilationError$fEqScriptCompilationError$fGenericScriptCompilationError$fBinaryScriptCompilationError$fNFDataScriptCompilationError$fShowSchemaError$fEqSchemaError$fGenericSchemaError$fBinarySchemaError$fNFDataSchemaError$fShowRelationalError$fEqRelationalError$fGenericRelationalError$fBinaryRelationalError$fNFDataRelationalError$fGenericServerError$fBinaryServerError$fEqServerErrorarityemptyAttributesnullattributesFromList attributeNameatomType atomTypes atomTypesList addAttributejoinAttributes addAttributesdeleteAttributeNamerenameAttributerenameAttributesatomTypeForAttributeNameattributeForNameisAttributeNameContainedprojectionAttributesForNamesattributesForNamesattributeNameSetattributeNamesattributesContainedattributeNamesContainednonMatchingAttributeNameSetmatchingAttributeNameSetattributeNamesNotContainedorderedAttributesorderedAttributeNamesattributesDifferencevectorUniqueifyverifyAttributesattributesAsMapunion intersectionCFSTypeCStatFSc_statfssizeofStructStatFSfsTypeSupportsJournalingLockTypeReadLock WriteLockLockFile lockStruct openLockFile closeLockFilelockFile unlockFile$fShowLockTypeFunctionalDependency,inclusionDependenciesForFunctionalDependencydupesindexedDiskSync NoDiskSync FsyncDiskSync writeFileSync renameSyncwriteBSFileSync printFdCountLoadSymbolErrorFuncNameModNameScriptSessionErrorScriptSessionLoadError ScriptSessionhscEnvatomFunctionBodyTypedbcFunctionBodyTypeinitScriptSession addImportshowType mkTypeForName compileScripttypeCheckScript mangleSymbol loadFunctionprefixUnderscore$fShowScriptSessionErrorSession SessionIddefaultSchemaNamedisconnectedTransactionisDirty subschemas schemaName setSchemaNametransactionTimestamptransactionParentIdstransactionChildIdstransactionSetChildren!filterTransactionInfoTransactions filterParentfilterTransaction argumentsfindDataConstructor atomTypeForDataConstructorDefArgatomTypeForDataConstructorresolveDataConstructorTypeVars!resolveDataConstructorArgTypeVarsresolveTypeConstructorTypeVarsresolveAttributeExprTypeVarsvalidateTypeConstructorDefvalidateDataConstructorDefvalidateDataConstructorDefArgatomTypeForTypeConstructor"atomTypeForTypeConstructorValidateatomTypeForAttributeExpr!isValidAtomTypeForTypeConstructorfindTypeConstructorresolveAtomTyperesolveAtomTypesInTypeVarMapresolveTypeInAtomresolveTypesInTuplevalidateAtomTypevalidateTypeVarMap validateTuple validateAtomatomTypeVerifytypeVarMapsVerifyprettyAtomTypeprettyAttributeresolveTypeVariablesresolveTypeVariableresolveFunctionReturnValue*resolvedAtomTypesForDataConstructorDefArgs(resolvedAtomTypeForDataConstructorDefArg OpenIntervalintervalSubTypesupportsIntervalsupportsOrdering atomComparecreateIntervalintervalAtomTypeintervalAtomFunctionsisIntervalAtomTypeintervalOverlapsintervalTypeConstructorMappingrelationForAtom atomToText emptyTuple tupleSizetupleAttributeNameSettupleAttributes tupleAssocsorderedTupleAssocs tupleAtomsatomForAttributeNameatomsForAttributeNamesvectorIndicesForAttributeNamesrelationForAttributeNametupleRenameAttributemkRelationTuplemkRelationTuplesmkRelationTupleFromMapsingleTupleSetJoinsingleTupleJoin vectorUnion tupleExtendtupleAtomExtend tupleProjecttupleIntersectionupdateTupleWithAtoms tupleToMap verifyTuple reorderTuple trimTuple emptyTupleSetsingletonTupleSetverifyTupleSet mkTupleSetmkTupleSetFromListRestrictionFilter attributesatomTypeForNamemkRelationFromListemptyRelationWithAttrs mkRelationmkRelationDeferVerifyrelationWithEmptyTupleSetmkRelationFromTuples relationTrue relationFalsesingletonTupleprojectrenamedegree cardinalitygroup restrictEqungroup tupleUngroupattributesForRelvalrestrictjoin differencerelMap relMogrifyrelFoldtoListimageRelationFortypesAsRelationrelationVariablesAsRelationrandomizeTupleOrderoneTuple tuplesListMergePreference PreferFirst PreferSecond PreferNeitherunionMergeMapsunionMergeRelationunionMergeRelVarsunionMergeAtomFunctions unionMergeTypeConstructorMapping"unionMergeDatabaseContextFunctionsSessions stmMapToList stmSetToListuuidAtomsessionsAsRelationCsvImportError CsvParseErrorAttributeMappingErrorHeaderAttributeMismatchErrorcsvDecodeOptions csvAsRelation parseCSVAtomPcapitalizedIdentifiertakeToEndOfDataparens quotedString$fShowCsvImportErrorinclusionDependencyForKeydatabaseContextExprForUniqueKey databaseContextExprForForeignKey inclusionDependencyForForeignKeyisForeignKeyForinclusionDependenciesAsRelationemptyDatabaseContextFunctiondatabaseContextFunctionForNameevalDatabaseContextFunctionbasicDatabaseContextFunctions#precompiledDatabaseContextFunctions!isScriptedDatabaseContextFunctiondatabaseContextFunctionScript!databaseContextFunctionReturnType%createScriptedDatabaseContextFunctionloadDatabaseContextFunctions"databaseContextFunctionsAsRelationattributesAsHTMLrelationAsHTML writeHTMLwriteRel tupleAsHTMLtupleSetAsHTML RecordAtomunAtomRecordRelationTupleunTuple relationAsCSV#$fDefaultOrderedRecordRelationTuple$fToFieldRecordAtom"$fToNamedRecordRecordRelationTuplefoldAtomFuncTypeatomFunctionForNameemptyAtomFunctioncompiledAtomFunctionevalAtomFunctionextractAtomFunctionTypeisScriptedAtomFunctionatomFunctionScriptcreateScriptedAtomFunctionloadAtomFunctionsatomFunctionsAsRelationeitherAtomTypeeitherTypeConstructorMappingeitherAtomFunctionsbasicTypeConstructorMapping AtomableGtoAtomG fromAtomG toAtomTypeGtoAtomsGtoAddTypeExprGgetConstructorsGgetConstructorArgsGAtomabletoAtomfromAtom toAtomType toAddTypeExprtypeToTypeConstructor$fAtomableGk:+:$fAtomableGk:*:$fAtomableGkU1$fAtomableGkM1$fAtomableGkM10$fAtomableGkM11$fAtomableGkK1$fAtomableNonEmpty $fAtomable[]$fAtomableEither$fAtomableMaybe$fAtomableBool$fAtomableByteString$fAtomableUTCTime $fAtomableDay$fAtomableText$fAtomableDouble $fAtomableInt$fAtomableInteger TupleableGtoTupleG toAttributesG fromTupleG isRecordTypeG TupleabletoTuple fromTuple toAttributes toInsertExpr toDefineExprtupleAssocsEqualityPredicatepartitionByAttributes toUpdateExpr toDeleteExprvalidateAttributes$fTupleableGU1$fTupleableGM1$fTupleableG:*:$fTupleableGM10$fTupleableGM11primitiveAtomFunctionsintegerAtomFuncLessThan boolAtomNot relationSum relationCount relationMax relationMincastInt castInteger PlotErrorInvalidAttributeCountErrorInvalidAttributeTypeErrorintFromAtomIndexgraph1DRelationpoints1DRelationgraph2DRelationpoints2DRelationgraph3DRelationpoints3DRelation plotRelation$fShowPlotErrorbasicAtomFunctionsprecompiledAtomFunctionsgetDirectoryNamestempTransactionDirtransactionDirtransactionInfoPath relvarsDir incDepsDir atomFuncsPath dbcFuncsDir typeConsPathsubschemasPathreadTransactionwriteTransaction writeRelVar writeRelVars readRelVarswriteAtomFuncs readAtomFuncs loadAtomFunc readAtomFunc writeDBCFuncs writeDBCFunc readDBCFuncs readDBCFunc writeIncDep writeIncDeps readIncDep readIncDepsreadSubschemaswriteSubschemaswriteTypeConstructorMappingreadTypeConstructorMapping$databaseContextAsDatabaseContextExprbasicDatabaseContext dateExamples suppliersRelsupplierProductsRel productsRel WithTCMap arbitrary' maybeToRightarbitraryRelationTuplearbitraryWithRangearbitraryRelationcreateArbitraryIntervalRelationalExprState DatabaseStateDatabaseStateElems ResultAccumresultAccumFuncresultAccumResultResultAccumFuncResultAccumNameRelationalExprStateElemsRelationalExprStateTupleElemsRelationalExprStateAttrsElemsDatabaseContextExprDetailsCountUpdatedTuplesdatabaseContextExprDetailsFuncfreshDatabaseStatemkRelationalExprState"mergeTuplesIntoRelationalExprState&mergeAttributesIntoRelationalExprStategetStateContextputStateContextstateElemsContextsetStateElemsContextevalRelationalExpr setRelVar deleteRelVarevalDatabaseContextExprevalDatabaseContextIOExprupdateTupleWithAtomExprscheckConstraintstypeForRelationalExprcontextWithEmptyTupleSetsliftEpredicateRestrictionFiltertupleExprCheckNewAttrNameextendTupleExpressionProcessor evalAtomExprtypeFromAtomExprverifyAtomExprTypes evalAttrExpr evalTupleExprevalAttributeNames$fShowRelationalExprStateElemsROTransactionGraphOperator ShowGraphTransactionGraphOperator JumpToHeadJumpToTransactionWalkBackToTimeBranch DeleteBranchMergeTransactionsCommitRollbackTransactionIdHeadBacktrack TransactionIdHeadParentBacktrack TransactionIdHeadBranchBacktrackTransactionStampHeadBacktrackTransactionIdLookupTransactionIdHeadNameLookupisCommitbootstrapTransactionGraphemptyTransactionGraphtransactionForHeadheadListheadNameForTransactiontransactionForIdtransactionsForIdsisRootTransactionparentTransactionschildTransactions addBranchaddDisconnectedTransactionaddTransactionToGraph validateGraphwalkParentTransactionswalkChildTransactions evalGraphOpgraphAsRelationtransactionParentsRelationcreateMergeTransactionvalidateHeadNamesubGraphOfFirstCommonAncestorpathToTransactionmergeTransactionsshowTransactionStructureXshowGraphStructureXfilterSubGraphcreateUnionMergeTransactionlookupTransaction traverseGraphbacktrackGraphautoMergeToHead $fShowTransactionIdHeadBacktrack$fEqTransactionIdHeadBacktrack"$fBinaryTransactionIdHeadBacktrack#$fGenericTransactionIdHeadBacktrack$fShowTransactionIdLookup$fEqTransactionIdLookup$fBinaryTransactionIdLookup$fGenericTransactionIdLookup$fEqTransactionGraphOperator$fShowTransactionGraphOperator $fBinaryTransactionGraphOperator!$fGenericTransactionGraphOperator $fShowROTransactionGraphOperatorshowTransactionStructureshowGraphStructure LockFileHashexpectedVersiontransactionLogFileNametransactionLogPath headsPath lockFilePathcheckForOtherVersionssetupDatabaseDirbootstrapDatabaseDirtransactionGraphPersisttransactionsPersisttransactionGraphHeadsPersisttransactionGraphHeadsLoadtransactionGraphLoadreadTransactionIfNecessarywriteGraphTransactionIdFile readGraphTransactionIdFileDigestreadGraphTransactionIdFilereadUTF8FileOrErrorTransGraphAttributeExprTransGraphAtomExpr"TransGraphRestrictionPredicateExprTransGraphTupleExprTransGraphExtendTupleExprTransGraphAttributeNamesTransGraphRelationalExprevalTransGraphRelationalExprevalTransGraphTupleExprevalTransGraphAtomExpr&evalTransGraphRestrictionPredicateExprevalTransGraphExtendTupleExprevalTransGraphAttributeExprevalTransAttributeNamesoptimizeRelationalExproptimizeRelationalExprReaderoptimizeDatabaseContextExpr!applyStaticRelationalOptimizationapplyStaticDatabaseOptimization applyStaticPredicateOptimization isTrueExpr isFalseExprisEmptyRelationExprreplaceStaticAtomExprsfindStaticRestrictionPredicatesisStaticAtomExprapplyStaticJoinEliminationapplyStaticRestrictionCollapsesequentialRestrictionsapplyStaticRestrictionPushdownnotificationChanges SchemaExpr AddSubschemaRemoveSubschema isomorphsvalidateSchemainvertisomorphInRelVarNamesisomorphsInRelVarNamesisomorphOutRelVarNamesisomorphsOutRelVarNamesvalidateRelationalExprInSchemaprocessRelationalExprInSchema#validateDatabaseContextExprInSchema"processDatabaseContextExprInSchema&processDatabaseContextExprSchemaUpdate'processDatabaseContextExprSchemasUpdate relExprMorphrelExprMogrifydatabaseContextExprMorph"applyRelationalExprSchemaIsomorphsinclusionDependencyInSchemainclusionDependenciesInSchemarelationVariablesInSchema%applyRelationVariablesSchemaIsomorphs%applySchemaIsomorphsToDatabaseContextcreateIncDepsForIsomorphevalSchemaExpr$fGenericSchemaExpr$fBinarySchemaExpr$fShowSchemaExprexecuteDatabaseContextExprexecuteRelationalExpr wIDEEASTASIAN zEROWIDTH basicZero ctrlCharswcwidthTableCellboxVboxHboxTLboxTRboxBLboxBRboxLBboxRBboxTBboxBBboxCaddRow cellLocations breakLines cellSizesrelationAsTable showParensshowAtom renderTable renderHeader renderHBarleftPaddedString renderRow renderBody repeatString showRelationstringDisplayLength DataFrameExpr convertExpr orderExprsoffsetlimitDataFrameTuple DataFrameorderstuplesOrderAscendingOrderDescendingOrderAttributeOrderAttributeOrderExpr ascending descending arbitrarysortDataFrameBy sortTuplesBycompareTupleByAttributeOrderscompareTupleByOneAttributeNametake'drop' toDataFrame fromDataFrame showDataFramedataFrameAsTabledataFrameAsHTML tuplesAsHTML $fEqOrder $fShowOrder$fGenericOrder $fBinaryOrder$fShowAttributeOrder$fGenericAttributeOrder$fBinaryAttributeOrder$fShowAttributeOrderExpr$fGenericAttributeOrderExpr$fBinaryAttributeOrderExpr$fEqDataFrameTuple$fShowDataFrameTuple$fGenericDataFrameTuple$fBinaryDataFrameTuple$fShowDataFrame$fGenericDataFrame$fBinaryDataFrame$fShowDataFrameExpr$fBinaryDataFrameExpr$fGenericDataFrameExpr!distributed-process-0.7.4-inplace*Control.Distributed.Process.Internal.TypesNodeId nodeAddressRetrieveTypeConstructorMappingExecuteAutoMergeToHeadRetrieveSessionIsDirty TestTimeoutRetrieveCurrentSchemaName&RetrieveDatabaseContextFunctionSummaryRetrieveAtomFunctionSummaryRetrieveRelationVariableSummaryRetrieveAtomTypesAsRelation CloseSessionCreateSessionAtHeadCreateSessionAtCommitRetrieveHeadTransactionIdRetrieveTransactionGraph"RetrievePlanForDatabaseContextExprRetrieveInclusionDependenciesExecuteSetCurrentSchemaExecuteSchemaExprExecuteTypeForRelationalExprExecuteHeadNameExecuteTransGraphRelationalExprExecuteGraphExprExecuteDatabaseContextIOExprExecuteDatabaseContextExprExecuteDataFrameExprExecuteRelationalExprLogoutLogin $fBinaryLogin$fGenericLogin$fBinaryLogout$fGenericLogout$fBinaryExecuteRelationalExpr$fGenericExecuteRelationalExpr$fBinaryExecuteDataFrameExpr$fGenericExecuteDataFrameExpr"$fBinaryExecuteDatabaseContextExpr#$fGenericExecuteDatabaseContextExpr$$fBinaryExecuteDatabaseContextIOExpr%$fGenericExecuteDatabaseContextIOExpr$fBinaryExecuteGraphExpr$fGenericExecuteGraphExpr'$fBinaryExecuteTransGraphRelationalExpr($fGenericExecuteTransGraphRelationalExpr$fBinaryExecuteHeadName$fGenericExecuteHeadName$$fBinaryExecuteTypeForRelationalExpr%$fGenericExecuteTypeForRelationalExpr$fBinaryExecuteSchemaExpr$fGenericExecuteSchemaExpr$fBinaryExecuteSetCurrentSchema $fGenericExecuteSetCurrentSchema%$fBinaryRetrieveInclusionDependencies&$fGenericRetrieveInclusionDependencies*$fBinaryRetrievePlanForDatabaseContextExpr+$fGenericRetrievePlanForDatabaseContextExpr $fBinaryRetrieveTransactionGraph!$fGenericRetrieveTransactionGraph!$fBinaryRetrieveHeadTransactionId"$fGenericRetrieveHeadTransactionId$fBinaryCreateSessionAtCommit$fGenericCreateSessionAtCommit$fBinaryCreateSessionAtHead$fGenericCreateSessionAtHead$fBinaryCloseSession$fGenericCloseSession#$fBinaryRetrieveAtomTypesAsRelation$$fGenericRetrieveAtomTypesAsRelation'$fBinaryRetrieveRelationVariableSummary($fGenericRetrieveRelationVariableSummary#$fBinaryRetrieveAtomFunctionSummary$$fGenericRetrieveAtomFunctionSummary.$fBinaryRetrieveDatabaseContextFunctionSummary/$fGenericRetrieveDatabaseContextFunctionSummary!$fBinaryRetrieveCurrentSchemaName"$fGenericRetrieveCurrentSchemaName$fBinaryTestTimeout$fGenericTestTimeout$fBinaryRetrieveSessionIsDirty$fGenericRetrieveSessionIsDirty$fBinaryExecuteAutoMergeToHead$fGenericExecuteAutoMergeToHead&$fBinaryRetrieveTypeConstructorMapping'$fGenericRetrieveTypeConstructorMappingConnectionErrorSetupDatabaseDirectoryErrorIOExceptionErrorNoSuchDatabaseByNameError LoginError ConnectionInProcessConnectionRemoteProcessConnectionEvaluatedNotification notificationreportOldRelationreportNewRelationConnectionInfoInProcessConnectionInfoRemoteProcessConnectionInfoRequestTimeoutExceptionRemoteProcessDiedExceptionNotificationCallback DatabaseNamePortHostnameemptyNotificationCallback createNodeIddefaultServerPortdefaultDatabaseNamedefaultHeadNamedefaultRemoteConnectionInforemoteDBLookupNameconnectProjectM36createSessionAtCommitcreateSessionAtHead addClientNode closeSessionclose closeRemote_currentSchemaNamesetCurrentSchemaNameexecuteDatabaseContextIOExprexecuteGraphExprexecuteTransGraphRelationalExprexecuteSchemaExprcommitrollbackplanForDatabaseContextExprtransactionGraphAsRelationheadTransactionIdheadNameatomTypesAsRelationdisconnectedTransactionIsDirtycallTestTimeout_transactionGraph_disconnectedTransaction_withTransactionexecuteDataFrameExpr%$fExceptionRemoteProcessDiedException"$fExceptionRequestTimeoutException $fShowRemoteProcessDiedException$fEqRemoteProcessDiedException$fShowRequestTimeoutException$fEqRequestTimeoutException$fBinaryEvaluatedNotification$fEqEvaluatedNotification$fShowEvaluatedNotification$fGenericEvaluatedNotification$fBinaryNotificationMessage$fEqNotificationMessage$fShowNotificationMessage$fGenericNotificationMessage$fShowConnectionError$fEqConnectionError$fGenericConnectionErrorReplyTimeout timeoutOrDiehandleExecuteRelationalExprhandleExecuteDataFrameExpr handleExecuteDatabaseContextExpr"handleExecuteDatabaseContextIOExprhandleExecuteHeadName handleLoginhandleExecuteGraphExpr%handleExecuteTransGraphRelationalExpr"handleExecuteTypeForRelationalExpr#handleRetrieveInclusionDependencies(handleRetrievePlanForDatabaseContextExprhandleRetrieveTransactionGraphhandleRetrieveHeadTransactionIdhandleCreateSessionAtCommithandleCreateSessionAtHeadhandleCloseSession!handleRetrieveAtomTypesAsRelation%handleRetrieveRelationVariableSummary!handleRetrieveAtomFunctionSummary,handleRetrieveDatabaseContextFunctionSummaryhandleRetrieveCurrentSchemaNamehandleExecuteSchemaExpr handleLogouthandleTestTimeouthandleRetrieveSessionIsDirtyhandleExecuteAutoMergeToHead$handleRetrieveTypeConstructorMapping ServerConfigpersistenceStrategycheckFS databaseNamebindHostbindPort ghcPkgPathsperRequestTimeouttestModedefaultServerConfig$fShowServerConfigparseArgsWithDefaultsparsePersistenceStrategy parseTestMode parseCheckFSparseDatabaseName parseHostname parsePortparseGhcPkgPath parseTimeout parseConfigparseConfigWithDefaults helpOptionserverDefinition initServer registerDBloggingNotificationCallback checkFSTypecheckFSErrorMsg launchServerDbError ConnErrorRelErrorTransactionRolledBackDbDbConnsimpleConnectProjectM36AtsimpleConnectProjectM36withTransactionUsingexecutequery executeOrErr queryOrErrcancelTransactionorCancelTransaction$fExceptionTransactionCancelled $fFunctorDb$fApplicativeDb $fMonadDb $fMonadIODb $fEqDbError $fShowDbError$fShowTransactionCancelled ClientNodesNotificationMessage"processTransactionGraphPersistencebase Data.EitherEither